gesso-core 0.6.19 → 0.6.21

package/dist/{index-8yhrkCnb.d.ts → index-DR8HAfh3.d.ts}

@@ -591,9 +591,10 @@ type UiTransitionSpec = {
 /**
  * What an element may write for one property of a `transition`.
  *
- * A bare number is a duration in milliseconds, which is what makes
- * `transition: { opacity: 200, transform: spring() }` read the way
- * That is how it was written.
+ * A bare number is a duration in milliseconds, so the common case,
+ * `transition: { opacity: 200, transform: 120 }`, reads the way a CSS
+ * transition does. A spring is for a property that is one number, like
+ * `opacity`: a transform only tweens (see `spring`).
  */
 type UiTransitionValue = number | UiTransitionSpec;
 /** A tween of `duration` milliseconds along `easing`. */
@@ -889,7 +890,304 @@ declare class UiEnvironment {
   providesOwn(name: string): boolean;
 }
 //#endregion
+//#region src/layout/TextMeasurer.d.ts
+type TextWrap = 'word' | 'char' | 'none';
+type TextOverflow = 'clip' | 'ellipsis';
+/**
+ * The font a piece of text is measured in.
+ *
+ * Structural rather than imported so that layout keeps depending on
+ * nothing above it; a `UiResolvedTextSpan` is one of these plus the
+ * fields that only paint reads.
+ */
+interface TextRunStyle {
+  fontFamily?: string;
+  fontWeight?: string | number;
+  fontSize?: number;
+  fontStyle?: string;
+  fontStretch?: string;
+  fontVariant?: string;
+  fontKerning?: string;
+  letterSpacing?: number;
+}
+/** A run of the paragraph with a font of its own, as offsets into the text. */
+interface TextRunSpan extends TextRunStyle {
+  readonly start: number;
+  readonly end: number;
+  /**
+   * The run is in the text but takes no room: every width that touches
+   * it counts it as nothing, and a line's `runs` leave it out, so no
+   * renderer has anything to draw for it.
+   */
+  readonly hidden?: boolean;
+}
+interface TextMeasureRequest {
+  text: string;
+  fontSize: number;
+  /** Available width. Wrapping and fit-content sizing happen against it. */
+  maxWidth?: number;
+  /**
+   * `maxWidth` is the box's own width, fixed from outside (a width
+   * set, or the box being painted): lines wrap against it, and a word
+   * wider than it overflows on a line of its own. Otherwise the
+   * paragraph is fit-content, and a word wider than `maxWidth` widens
+   * it, every line wrapping against that wider box, as CSS lays out a
+   * box sized by its content.
+   */
+  exactWidth?: boolean;
+  /**
+   * Font family for platforms that can shape text.
+   *
+   * Deterministic measurers may ignore every style field; they
+   * are hints for platform-backed implementations only.
+   */
+  fontFamily?: string;
+  fontWeight?: string | number;
+  lineHeight?: number;
+  letterSpacing?: number;
+  fontStyle?: string;
+  fontStretch?: string;
+  fontVariant?: string;
+  fontKerning?: string;
+  /** Default 'word'. */
+  wrap?: TextWrap;
+  /** Keep at most this many lines. */
+  maxLines?: number;
+  /** What happens to a line that does not fit. Default 'clip'. */
+  overflow?: TextOverflow;
+  /**
+   * Runs of `text` with a font of their own, in order and not
+   * overlapping. Text outside every run is measured in the request's
+   * own font.
+   *
+   * Only the fields that change a width are here. A run that differs
+   * from its neighbours only in colour, background or underline is not
+   * in this list at all, so it costs a paint and never a re-layout.
+   */
+  spans?: readonly TextRunSpan[];
+}
+/** One run of a line: where it sits in the line and which span it came from. */
+interface TextLineRun {
+  /** Index into the request's `spans`, or -1 for text outside every run. */
+  span: number;
+  /** Offsets into the source text. */
+  start: number;
+  end: number;
+  text: string;
+  /** Distance from the line's left edge to this run's left edge. */
+  x: number;
+  width: number;
+}
+/** One laid-out line. `text` is what gets drawn and may end in an ellipsis. */
+interface TextLine {
+  /** Offsets into the source text; hanging spaces and the ellipsis are outside them. */
+  start: number;
+  end: number;
+  text: string;
+  width: number;
+  /**
+   * The line cut at its runs, present only for a paragraph that has
+   * spans. A hidden run is not among them.
+   *
+   * Measured once, here, where the line's own width is measured. That
+   * is what keeps a spanned paragraph as cheap to paint as a plain
+   * one: a renderer walks these and asks the platform for nothing.
+   */
+  runs?: readonly TextLineRun[];
+}
+interface FontMetrics {
+  /** Distance from the alphabetic baseline to the top of the glyph box. */
+  ascent: number;
+  /** Distance from the alphabetic baseline to the bottom of the glyph box. */
+  descent: number;
+}
+/**
+ * A measured paragraph: everything layout, alignment and painting need.
+ *
+ * `width` is fit-content, `height` is lines × lineHeight, and
+ * `firstBaseline` is the distance from the paragraph top to the first
+ * line's alphabetic baseline (half-leading plus ascent).
+ */
+interface ParagraphLayout {
+  lines: TextLine[];
+  width: number;
+  height: number;
+  lineHeight: number;
+  ascent: number;
+  descent: number;
+  firstBaseline: number;
+  /** Widest unbreakable segment under the requested wrap mode. */
+  minContentWidth: number;
+  /** Width with no wrapping at all. */
+  maxContentWidth: number;
+}
+/**
+ * Abstraction between layout and text platforms.
+ *
+ * Layout never measures text itself; a platform layer
+ * (Canvas2D, WebGPU, tests) supplies an implementation.
+ */
+interface TextMeasurer {
+  measure(request: TextMeasureRequest): Size;
+  layout(request: TextMeasureRequest): ParagraphLayout;
+  /**
+   * The advance width of one run in the request's font. Caret and
+   * selection geometry is built from prefix widths, so it has to come
+   * from the same source as the line widths.
+   */
+  measureRunWidth(text: string, request: TextMeasureRequest): number;
+  /**
+   * Forgets every cached answer. Called when what a font string means
+   * has changed under the measurer: a declared face finished loading,
+   * so widths measured with its fallback are wrong now. Measurers with
+   * nothing cached need not implement it.
+   */
+  invalidate?(): void;
+  /**
+   * Counts `invalidate` calls. A caller that keeps a paragraph past the
+   * call that returned it (the layout engine keeps each node's last
+   * one) may trust it only while this is unchanged. A measurer that
+   * leaves it out is asked again every time.
+   */
+  readonly generation?: number;
+}
+/**
+ * The primitive a platform has to provide: the advance width of one
+ * run of text, and the font's vertical metrics. Everything above it
+ * is shared (see ParagraphLayout.ts).
+ */
+interface TextRunMeasurer {
+  measureRunWidth(text: string, request: TextMeasureRequest): number;
+  fontMetrics(request: TextMeasureRequest): FontMetrics;
+}
+/**
+ * The widths of a paragraph whose runs have fonts of their own.
+ *
+ * Everything above it — line breaking, hanging blanks, the ellipsis,
+ * caret and selection geometry — asks for the width of a stretch of
+ * the text by its offsets rather than by its characters, and this
+ * splits that stretch at the run boundaries and measures each piece in
+ * its own font. That is the whole of what a span costs: the paragraph
+ * algorithm is unchanged, and a paragraph with no spans never builds
+ * one of these at all.
+ */
+interface SpannedRuns {
+  /** The runs, as the request gave them. */
+  readonly spans: readonly TextRunSpan[];
+  /** Index of the run covering `offset`, or -1 where no run does. */
+  indexAt(offset: number): number;
+  /** The request an offset is measured with: its run's, or the paragraph's. */
+  requestAt(offset: number): TextMeasureRequest;
+  /** Whether the character at `offset` is in a hidden run. */
+  hiddenAt(offset: number): boolean;
+  /** Width of `text.slice(start, end)`, measured run by run. */
+  width(text: string, start: number, end: number): number;
+  /**
+   * Width of a string that is not in the text, in the font of the run
+   * covering `offset`: the ellipsis, and the space a tab is counted
+   * as.
+   */
+  widthOf(run: string, offset: number): number;
+  /**
+   * `text.slice(start, end)` cut at the run boundaries, each piece
+   * placed from `x`. Hidden pieces take no room and are left out.
+   */
+  cut(text: string, start: number, end: number, x: number): TextLineRun[];
+}
+/**
+ * Builds the run widths for a request, or undefined when it has no
+ * runs.
+ *
+ * One request object per run, built once: the paragraph cache means a
+ * paragraph is laid out once per distinct request, so this runs once
+ * per paragraph rather than once per frame.
+ */
+declare function spannedRunsFor(request: TextMeasureRequest, runs: Pick<TextRunMeasurer, 'measureRunWidth'>): SpannedRuns | undefined;
+/**
+ * Base class for measurers: implement the two primitives and the
+ * paragraph algorithm does the rest.
+ *
+ * **Every paragraph is laid out once per distinct request.** The same
+ * request arrives several times a frame and on every frame after: the
+ * layout engine asks when it measures the node, and both renderers ask
+ * again when they paint it, because a `PaintState` and a box are all a
+ * renderer holds. Without a cache a repaint is a line break, and a
+ * transition that repaints the whole screen for half a second breaks
+ * every paragraph on it sixty times a second. Measured on Sluice's
+ * Bluesky feed opening a post: 30 to 50 ms a frame in `segmentParagraph`,
+ * `measureRunWidth` and `applySpacing`, against under 13 ms on the same
+ * click over short Wikipedia titles. The cache is keyed by every field
+ * of the request, so a paragraph that changed in any way is laid out
+ * again, and it is least-recently-used with a cap, so a feed that
+ * mounts forty new rows a second does not grow it without bound.
+ *
+ * The result is shared between callers and must not be mutated.
+ */
+declare abstract class ParagraphTextMeasurer implements TextMeasurer, TextRunMeasurer {
+  private readonly paragraphs;
+  /**
+   * Paragraphs that came out the same at every width they fit in, by
+   * their key without the width; see `layoutFitsAnyWidth`.
+   *
+   * A resize asks every paragraph again at a width a few pixels from
+   * the last, and a title, a caption or a label that fitted before
+   * fits still: its lines, its box and everything else are what they
+   * were. Keyed by its width as well, each of those missed on every
+   * step of a dragged window edge and was laid out again, and the
+   * box it was then painted in (its own width, exact) missed once
+   * more.
+   */
+  private readonly fitting;
+  private generations;
+  abstract measureRunWidth(text: string, request: TextMeasureRequest): number;
+  abstract fontMetrics(request: TextMeasureRequest): FontMetrics;
+  layout(request: TextMeasureRequest): ParagraphLayout;
+  measure(request: TextMeasureRequest): Size;
+  /** How many paragraphs are remembered right now; for specs. */
+  get cachedParagraphs(): number;
+  get generation(): number;
+  /**
+   * Forgets every laid-out paragraph. A subclass that caches its own
+   * primitives overrides this and calls it, so a font that finished
+   * loading invalidates the lines as well as the widths they were
+   * built from.
+   */
+  invalidate(): void;
+}
+interface FixedMetricsOptions {
+  /** Advance of every glyph as a fraction of the font size. Default 0.6. */
+  glyphWidth?: number;
+  /** Ascent as a fraction of the font size. Default 0.8. */
+  ascent?: number;
+  /** Descent as a fraction of the font size. Default 0.2. */
+  descent?: number;
+}
+/**
+ * Deterministic measurer: every glyph is `glyphWidth` em wide, the
+ * font is `ascent + descent` em tall, and the default line is 1.2em.
+ *
+ * Intended for tests and headless environments. With `glyphWidth: 1`
+ * it reproduces the Ahem test font exactly, which is how the layout
+ * conformance fixtures compare real wrapping text against Chrome.
+ */
+declare class CharacterCountTextMeasurer extends ParagraphTextMeasurer {
+  private readonly glyphWidth;
+  private readonly ascentFactor;
+  private readonly descentFactor;
+  constructor(options?: FixedMetricsOptions);
+  measureRunWidth(text: string, request: TextMeasureRequest): number;
+  fontMetrics(request: TextMeasureRequest): FontMetrics;
+}
+//#endregion
 //#region src/layout/LayoutRecord.d.ts
+/** A text leaf's paragraph, the request it was laid out for, and the measurer generation it was laid out under. */
+interface TextMemo {
+  readonly request: TextMeasureRequest;
+  readonly paragraph: ParagraphLayout;
+  readonly generation: number;
+  /** The paragraph is the same at any width it fits in; see `layoutFitsAnyWidth`. */
+  readonly fitsAnyWidth: boolean;
+}
 /**
  * Mutable per-node layout projection owned by LayoutEngine.
  *
@@ -1058,6 +1356,8 @@ declare class LayoutRecord {
    * multiline, the overlay scrollbars.
    */
   scrollsText: boolean;
+  /** A scroll container set to show no scrollbars (\`scrollbars: 'none'\`). */
+  hidesScrollbars: boolean;
   /**
    * A multiline editable, which shows the overlay scrollbars a scroll
    * container does over its own text. A single-line field scrolls
@@ -1122,6 +1422,23 @@ declare class LayoutRecord {
   contentHeight: number;
   /** Constraints this record was last measured under. */
   lastConstraints: Constraints;
+  /**
+   * The paragraphs a text leaf was last measured as, one asked with a
+   * width and one without; see `LayoutEngine.measureLeaf`. Flex asks
+   * an item both questions every pass (its max-content basis, then its
+   * final width), so one slot would be overwritten by the other every
+   * time. Null until the node is measured as text that way.
+   *
+   * **Not reset.** These are the one thing a record carries from one
+   * full pass into the next, on purpose: a full pass re-asks every
+   * text leaf, and a memo that every pass cleared would answer
+   * nothing a resize asks. They are safe to keep because they check
+   * themselves — a memo is used only when every field of the request
+   * it was laid out for matches and the measurer has not been
+   * invalidated since — rather than trusting that nothing changed.
+   */
+  textBounded: TextMemo | null;
+  textUnbounded: TextMemo | null;
   /**
    * The percentage base the current measurement resolved against, and
    * whether the node has a length that resolves against one.
@@ -1212,6 +1529,20 @@ declare class LayoutRecord {
   propsPass: number;
   propsBaseWidth: number | undefined;
   propsBaseHeight: number | undefined;
+  /**
+   * The node's `propertyVersion` when its layout properties were last
+   * resolved, and whether that resolution read the node and nothing
+   * else (no inherited direction, no scroll leader). Together with the
+   * percentage base they let a later pass, a full one included, keep
+   * what the last one resolved instead of reading forty properties
+   * again; see `LayoutEngine.resolveLayoutProps`.
+   *
+   * **Not reset,** with the fields they vouch for: `reset()` leaves
+   * every field `resolveLayoutProps` writes as it was, because these
+   * say whether it is still right.
+   */
+  propsVersion: number;
+  propsFromNodeAlone: boolean;
   /**
    * Returns the record to the state a freshly constructed one is in,
    * so a full layout can reuse the object instead of replacing it.
@@ -1226,7 +1557,9 @@ declare class LayoutRecord {
    * never reused across.
    *
    * **Every field above has to appear here, with the value it is
-   * declared with.** A field that is added and not reset would carry
+   * declared with,** but the two text memos and the resolved layout
+   * properties, which check themselves and are kept across passes on
+   * purpose. A field that is added and not reset would carry
    * one pass's answer into the next, which is the kind of fault that
    * shows as a stale box on a screen and as nothing at all in a test
    * that lays out once. `LayoutRecord.spec.ts` compares a reset record
@@ -1722,8 +2055,23 @@ declare class UiNode {
    *   opacity  → 0.5
    *   visible  → true
    *   width    → 200
+   *
+   * Read it directly; write it through `setProperty` and
+   * `removeProperty`, which count the change in `propertyVersion`.
    */
   readonly properties: Map<string, unknown>;
+  /**
+   * Counts writes to `properties`.
+   *
+   * Lets something derived from a node's own properties tell that it
+   * is still right without reading them again. The layout engine
+   * resolves forty of them into each record, and on a full pass over a
+   * tree where nothing changed that reading was most of a sixth of the
+   * pass. A counter is exact where a dirty flag is not: flags are
+   * cleared by whichever pass runs next, and a record is resolved by
+   * whichever pass reaches it.
+   */
+  propertyVersion: number;
   /**
    * Values a modifier has written over the element's own.
    *
@@ -1763,6 +2111,8 @@ declare class UiNode {
   isDirty(): boolean;
   getProperty<T>(property: NodeProperty): T | undefined;
   setProperty<T>(property: NodeProperty, value: T): void;
+  /** Removes a property; whether it was there. */
+  removeProperty(property: NodeProperty): boolean;
 }
 //#endregion
 //#region src/layout/LayoutTypes.d.ts
@@ -2064,6 +2414,8 @@ declare class DirtyNodeSet {
   delete(node: UiNode): boolean;
   get size(): number;
   isEmpty(): boolean;
+  /** The nodes in the set, without draining it. Not to be changed while walked. */
+  values(): IterableIterator<UiNode>;
   /**
    * Whether any node in the set carries one of `flags`, without
    * draining it.
@@ -3023,8 +3375,13 @@ declare class UiFocusManager {
    * when that scope was pushed, when that node is still in the tree
    * and still focusable. Otherwise focus is dropped rather than left
    * on a node the scope was hiding.
+   *
+   * Given its root, only that scope ends: none, when it has gone already
+   * (its subtree removed, which pops it), so a trap released after its
+   * content was taken away cannot end the one under it, a submenu's
+   * menu's; and one under another is taken out where it is.
    */
-  popScope(): void;
+  popScope(root?: UiNode): void;
   /**
    * Reacts to a subtree leaving the graph.
    *
@@ -5189,6 +5546,19 @@ interface LazyListOptions {
   readonly estimatedExtent: number;
   /** Items mounted beyond each edge of the viewport. Default 3. */
   readonly overscan?: number;
+  /**
+   * Reuse an item's node for the item that takes its place, as a native
+   * list recycles its cells: an item scrolling out of the window hands its
+   * node, and its component, to the one scrolling in, which is given the
+   * new index. Nothing is built or torn down as the list scrolls, only
+   * updated, which is most of what a scroll through rows of many nodes
+   * costs.
+   *
+   * \`key\` is not used: items are keyed by their slot. The component an
+   * item renders must follow its inputs as they change, since one keeps
+   * its instance from item to item.
+   */
+  readonly recycle?: boolean;
   /** Identity of an item, for reconciliation. Default: its index. */
   readonly key?: (index: number) => string | number;
   /**
@@ -5293,6 +5663,15 @@ declare class UiVirtualWindow {
   private count;
   private readonly estimate;
   private readonly overscan;
+  private readonly recycle;
+  /**
+   * The slot each mounted item is keyed by, when recycling: an item keeps
+   * its slot while it stays, and one leaving gives its slot to the next
+   * one to come, whose element then matches the node it leaves behind.
+   */
+  private readonly slotOf;
+  private readonly freeSlots;
+  private nextSlot;
   private readonly keyOf;
   private readonly renderItem;
   private readonly grid;
@@ -6443,6 +6822,14 @@ declare const UiProperties: {
    * descendants stick to its edges.
    */
   readonly overflow: UiPropertyDefinition<UiOverflow | undefined>;
+  /**
+   * Whether a scroll container shows its overlay scrollbars: \`'auto'\`
+   * (the default) while scrolling, \`'none'\` never, and then they cannot
+   * be grabbed either. For a container scrolled by something else, as a
+   * picture is moved inside a window onto it, where a bar would claim
+   * the person could scroll it.
+   */
+  readonly scrollbars: UiPropertyDefinition<"auto" | "none" | undefined>;
   readonly inset: UiPropertyDefinition<UiLength | undefined>;
   readonly backgroundColor: UiPropertyDefinition<UiColorValue | undefined>;
   /**
@@ -6537,6 +6924,12 @@ declare const UiProperties: {
   readonly multiline: UiPropertyDefinition<boolean | undefined>;
   /** The text can be selected and copied but not changed. */
   readonly readOnly: UiPropertyDefinition<boolean | undefined>;
+  /**
+   * A password field: every character is drawn as a bullet, copy and
+   * cut take nothing, and the shell edits it through a password input.
+   * The value itself is unchanged. Single-line only.
+   */
+  readonly secret: UiPropertyDefinition<boolean | undefined>;
   /** Colour of the caret; defaults to the text colour. */
   readonly caretColor: UiPropertyDefinition<UiColorValue | undefined>;
   /** Colour behind selected text; defaults to a translucent theme primary. */
@@ -6949,7 +7342,7 @@ type CommonProps = IdentityProps & UiEventProps & BoxModelProps & FlexItemProps
  * layout replaces whatever the container would have done with its
  * children, whichever container it is; see `layout/CustomLayout.ts`.
  */
-type ContainerProps = CommonProps & PropsOf<'overflow' | 'scrollX' | 'scrollY' | 'scrollWith' | 'scrollWithAxis' | 'scrollBehavior' | 'overscrollBehavior' | 'layout'>;
+type ContainerProps = CommonProps & PropsOf<'overflow' | 'scrollbars' | 'scrollX' | 'scrollY' | 'scrollWith' | 'scrollWithAxis' | 'scrollBehavior' | 'overscrollBehavior' | 'layout'>;
 /** Props of a flex container: Row, Column, ScrollView. */
 type FlexContainerProps = ContainerProps & PropsOf<'gap' | 'rowGap' | 'columnGap' | 'x' | 'y' | 'flexWrap' | 'alignContent' | 'direction'>;
 /**
@@ -6975,7 +7368,7 @@ type TextProps = CommonProps & TextContentProps;
  * 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' | 'spans' | 'placeholder' | 'multiline' | 'readOnly' | 'textWrap' | 'verticalAlign' | 'caretColor' | 'selectionColor' | 'placeholderColor'>;
+type EditableTextProps = CommonProps & PropsOf<'value' | 'spans' | 'placeholder' | 'multiline' | 'readOnly' | 'secret' | '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.
@@ -7083,6 +7476,15 @@ interface UiGraphBuilderOptions {
 declare class UiGraphBuilder {
   private readonly graph;
   private readonly refs;
+  /**
+   * The definition each node was last reconciled from. A definition is
+   * a description that is never changed once made, so the same object
+   * again has nothing new to say: a lazy list hands back the row it made
+   * for an index on every scroll, and reconciling seventy unchanged rows
+   * (their props, then every node of each row's component) to mount the
+   * four that scrolled in cost a 165 Hz frame its budget.
+   */
+  private readonly reconciledFrom;
   private readonly modifiers;
   private nextChildrenBindingId;
   /**
@@ -7442,6 +7844,14 @@ declare class UiGraph {
    */
   insertBefore(parent: UiNode, child: UiNode, reference: UiNode | null): void;
   removeNode(node: UiNode): void;
+  /**
+   * Moves a child before \`reference\` among its own siblings, or to the
+   * end when that is null. Its parent is unchanged, and so is everything
+   * it inherits, so its subtree is not visited: a lazy list recycling its
+   * rows moves one from end to end on every frame of a scroll, and
+   * re-inheriting walked the whole row each time.
+   */
+  moveWithin(child: UiNode, reference: UiNode | null): void;
   detachNode(node: UiNode): void;
   /**
    * The binding driving one property of one node, if any.
@@ -7971,377 +8381,119 @@ declare function graphemeBoundaries(text: string): number[];
  */
 declare function nextWordEnd(text: string, index: number): number;
 /**
- * Where a word-wise move to the left stops: back over spaces and
- * punctuation, to the start of the previous word.
- */
-declare function previousWordStart(text: string, index: number): number;
-/**
- * The word under `index`, for a double-click: a run of word
- * characters, else the run of whatever else is there (spaces,
- * punctuation), never crossing a newline.
- */
-declare function wordRangeAt(text: string, index: number): {
-  start: number;
-  end: number;
-};
-/** The offset just after the previous newline, or 0. */
-declare function lineStartAt(text: string, index: number): number;
-/** The offset of the next newline, or `text.length`. */
-declare function lineEndAt(text: string, index: number): number;
-//#endregion
-//#region src/editing/TextGeometry.d.ts
-/**
- * A placed line, as `placeLines` in the text renderer produces: the
- * source offsets it covers, its box after alignment, and its text.
- */
-interface PlacedLine {
-  readonly text: string;
-  readonly start: number;
-  readonly end: number;
-  readonly x: number;
-  readonly y: number;
-  readonly width: number;
-  readonly height: number;
-}
-/**
- * The advance width of a run in the paragraph's font.
- *
- * `start` is the run's first character's offset in the source text,
- * and is what a paragraph with runs of its own needs to know which
- * font to measure in; a paragraph in one font ignores it. Omitted for
- * a string that is not in the text at all, such as the space a
- * selection past the end of a line is widened by.
- */
-type RunMeasure = (text: string, start?: number) => number;
-interface CaretRect {
-  x: number;
-  y: number;
-  height: number;
-  /** Index of the line the caret is on. */
-  line: number;
-}
-/**
- * Caret and selection geometry over laid-out lines.
- *
- * The lines are the paragraph the layout engine sized the node with
- * and the renderer draws, so a caret computed here sits exactly where
- * the glyphs are. Widths come from the same measurer: the x of offset
- * `n` on a line is the width of that line's first `n` characters.
- *
- * Direction: `rtl` mirrors every x against the line's right edge, so a
- * right-to-left paragraph places its caret and selection from the
- * right. Runs of mixed direction within one line are not reordered —
- * the renderers do not shape them either — so this is direction-aware
- * rather than fully bidirectional, and says so.
- */
-/**
- * The line an offset belongs to. Hanging spaces at a wrap belong to
- * the line before the break; the first character after the break
- * starts the next line.
- */
-declare function lineIndexForOffset(lines: readonly PlacedLine[], offset: number): number;
-/**
- * The offset a line's caret positions run to, hanging spaces included:
- * the text's end on the last line, else up to the break — the newline
- * character itself, or the first character of the next line.
- *
- * `line.end` stops at the last glyph, since spaces at a wrap hang and
- * have no width in layout. The caret still has to move through them,
- * as it does in a textarea, so geometry measures them from `text`.
- */
-declare function lineLimit(lines: readonly PlacedLine[], index: number, text: string): number;
-/** Where the caret for `offset` is drawn. */
-declare function caretRectFor(lines: readonly PlacedLine[], text: string, offset: number, measure: RunMeasure, rtl: boolean): CaretRect;
-/** The line whose box contains `y`, clamped to the first and last. */
-declare function lineIndexAtY(lines: readonly PlacedLine[], y: number): number;
-/** The caret position nearest to a point: the boundary closest to `x` on the line under `y`. */
-declare function offsetAtPoint(lines: readonly PlacedLine[], text: string, x: number, y: number, measure: RunMeasure, rtl: boolean): number;
-/**
- * The caret position on one line nearest to `x`. Widths grow with the
- * prefix, so the boundary is found by bisection: O(log n) measures per
- * click on a line of n graphemes.
- *
- * On the last line the trailing spaces are positions too, so a click
- * past the text lands after them. On a wrapped line the hanging spaces
- * are not: a click past the glyphs stops before the break, as it does
- * in a textarea.
- */
-declare function offsetAtX(lines: readonly PlacedLine[], index: number, text: string, x: number, measure: RunMeasure, rtl: boolean): number;
-/**
- * The offset a vertical move lands on: the position nearest the
- * caret's x (or `goalX`, the x of the line the run of moves started
- * on) on the adjacent line. Null when there is no line that way, which
- * callers turn into "go to the start / end of the text".
- */
-declare function offsetForVerticalMove(lines: readonly PlacedLine[], text: string, offset: number, direction: -1 | 1, measure: RunMeasure, rtl: boolean, goalX?: number): {
-  offset: number;
-  x: number;
-} | null;
-/**
- * The boxes covering `[start, end)`, one per line touched. Hanging
- * spaces inside the range are highlighted at their width; a line the
- * range runs past with nothing hanging gets a space's width more, so a
- * selected line break is visible.
- */
-declare function selectionRects(lines: readonly PlacedLine[], text: string, start: number, end: number, measure: RunMeasure, rtl: boolean): LayoutBox[];
-//#endregion
-//#region src/layout/TextMeasurer.d.ts
-type TextWrap = 'word' | 'char' | 'none';
-type TextOverflow = 'clip' | 'ellipsis';
-/**
- * The font a piece of text is measured in.
- *
- * Structural rather than imported so that layout keeps depending on
- * nothing above it; a `UiResolvedTextSpan` is one of these plus the
- * fields that only paint reads.
- */
-interface TextRunStyle {
-  fontFamily?: string;
-  fontWeight?: string | number;
-  fontSize?: number;
-  fontStyle?: string;
-  fontStretch?: string;
-  fontVariant?: string;
-  fontKerning?: string;
-  letterSpacing?: number;
-}
-/** A run of the paragraph with a font of its own, as offsets into the text. */
-interface TextRunSpan extends TextRunStyle {
-  readonly start: number;
-  readonly end: number;
-  /**
-   * The run is in the text but takes no room: every width that touches
-   * it counts it as nothing, and a line's `runs` leave it out, so no
-   * renderer has anything to draw for it.
-   */
-  readonly hidden?: boolean;
-}
-interface TextMeasureRequest {
-  text: string;
-  fontSize: number;
-  /** Available width. Wrapping and fit-content sizing happen against it. */
-  maxWidth?: number;
-  /**
-   * Font family for platforms that can shape text.
-   *
-   * Deterministic measurers may ignore every style field; they
-   * are hints for platform-backed implementations only.
-   */
-  fontFamily?: string;
-  fontWeight?: string | number;
-  lineHeight?: number;
-  letterSpacing?: number;
-  fontStyle?: string;
-  fontStretch?: string;
-  fontVariant?: string;
-  fontKerning?: string;
-  /** Default 'word'. */
-  wrap?: TextWrap;
-  /** Keep at most this many lines. */
-  maxLines?: number;
-  /** What happens to a line that does not fit. Default 'clip'. */
-  overflow?: TextOverflow;
-  /**
-   * Runs of `text` with a font of their own, in order and not
-   * overlapping. Text outside every run is measured in the request's
-   * own font.
-   *
-   * Only the fields that change a width are here. A run that differs
-   * from its neighbours only in colour, background or underline is not
-   * in this list at all, so it costs a paint and never a re-layout.
-   */
-  spans?: readonly TextRunSpan[];
-}
-/** One run of a line: where it sits in the line and which span it came from. */
-interface TextLineRun {
-  /** Index into the request's `spans`, or -1 for text outside every run. */
-  span: number;
-  /** Offsets into the source text. */
-  start: number;
-  end: number;
-  text: string;
-  /** Distance from the line's left edge to this run's left edge. */
-  x: number;
-  width: number;
-}
-/** One laid-out line. `text` is what gets drawn and may end in an ellipsis. */
-interface TextLine {
-  /** Offsets into the source text; hanging spaces and the ellipsis are outside them. */
-  start: number;
-  end: number;
-  text: string;
-  width: number;
-  /**
-   * The line cut at its runs, present only for a paragraph that has
-   * spans. A hidden run is not among them.
-   *
-   * Measured once, here, where the line's own width is measured. That
-   * is what keeps a spanned paragraph as cheap to paint as a plain
-   * one: a renderer walks these and asks the platform for nothing.
-   */
-  runs?: readonly TextLineRun[];
-}
-interface FontMetrics {
-  /** Distance from the alphabetic baseline to the top of the glyph box. */
-  ascent: number;
-  /** Distance from the alphabetic baseline to the bottom of the glyph box. */
-  descent: number;
+ * Where a word-wise move to the left stops: back over spaces and
+ * punctuation, to the start of the previous word.
+ */
+declare function previousWordStart(text: string, index: number): number;
+/**
+ * The word under `index`, for a double-click: a run of word
+ * characters, else the run of whatever else is there (spaces,
+ * punctuation), never crossing a newline.
+ */
+declare function wordRangeAt(text: string, index: number): {
+  start: number;
+  end: number;
+};
+/** The offset just after the previous newline, or 0. */
+declare function lineStartAt(text: string, index: number): number;
+/** The offset of the next newline, or `text.length`. */
+declare function lineEndAt(text: string, index: number): number;
+//#endregion
+//#region src/editing/TextGeometry.d.ts
+/**
+ * A placed line, as `placeLines` in the text renderer produces: the
+ * source offsets it covers, its box after alignment, and its text.
+ */
+interface PlacedLine {
+  readonly text: string;
+  readonly start: number;
+  readonly end: number;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
 }
 /**
- * A measured paragraph: everything layout, alignment and painting need.
+ * The advance width of a run in the paragraph's font.
  *
- * `width` is fit-content, `height` is lines × lineHeight, and
- * `firstBaseline` is the distance from the paragraph top to the first
- * line's alphabetic baseline (half-leading plus ascent).
+ * `start` is the run's first character's offset in the source text,
+ * and is what a paragraph with runs of its own needs to know which
+ * font to measure in; a paragraph in one font ignores it. Omitted for
+ * a string that is not in the text at all, such as the space a
+ * selection past the end of a line is widened by.
  */
-interface ParagraphLayout {
-  lines: TextLine[];
-  width: number;
+type RunMeasure = (text: string, start?: number) => number;
+interface CaretRect {
+  x: number;
+  y: number;
   height: number;
-  lineHeight: number;
-  ascent: number;
-  descent: number;
-  firstBaseline: number;
-  /** Widest unbreakable segment under the requested wrap mode. */
-  minContentWidth: number;
-  /** Width with no wrapping at all. */
-  maxContentWidth: number;
+  /** Index of the line the caret is on. */
+  line: number;
 }
 /**
- * Abstraction between layout and text platforms.
+ * Caret and selection geometry over laid-out lines.
  *
- * Layout never measures text itself; a platform layer
- * (Canvas2D, WebGPU, tests) supplies an implementation.
+ * The lines are the paragraph the layout engine sized the node with
+ * and the renderer draws, so a caret computed here sits exactly where
+ * the glyphs are. Widths come from the same measurer: the x of offset
+ * `n` on a line is the width of that line's first `n` characters.
+ *
+ * Direction: `rtl` mirrors every x against the line's right edge, so a
+ * right-to-left paragraph places its caret and selection from the
+ * right. Runs of mixed direction within one line are not reordered —
+ * the renderers do not shape them either — so this is direction-aware
+ * rather than fully bidirectional, and says so.
  */
-interface TextMeasurer {
-  measure(request: TextMeasureRequest): Size;
-  layout(request: TextMeasureRequest): ParagraphLayout;
-  /**
-   * The advance width of one run in the request's font. Caret and
-   * selection geometry is built from prefix widths, so it has to come
-   * from the same source as the line widths.
-   */
-  measureRunWidth(text: string, request: TextMeasureRequest): number;
-  /**
-   * Forgets every cached answer. Called when what a font string means
-   * has changed under the measurer: a declared face finished loading,
-   * so widths measured with its fallback are wrong now. Measurers with
-   * nothing cached need not implement it.
-   */
-  invalidate?(): void;
-}
 /**
- * The primitive a platform has to provide: the advance width of one
- * run of text, and the font's vertical metrics. Everything above it
- * is shared (see ParagraphLayout.ts).
+ * The line an offset belongs to. Hanging spaces at a wrap belong to
+ * the line before the break; the first character after the break
+ * starts the next line.
  */
-interface TextRunMeasurer {
-  measureRunWidth(text: string, request: TextMeasureRequest): number;
-  fontMetrics(request: TextMeasureRequest): FontMetrics;
-}
+declare function lineIndexForOffset(lines: readonly PlacedLine[], offset: number): number;
 /**
- * The widths of a paragraph whose runs have fonts of their own.
+ * The offset a line's caret positions run to, hanging spaces included:
+ * the text's end on the last line, else up to the break — the newline
+ * character itself, or the first character of the next line.
  *
- * Everything above it — line breaking, hanging blanks, the ellipsis,
- * caret and selection geometry — asks for the width of a stretch of
- * the text by its offsets rather than by its characters, and this
- * splits that stretch at the run boundaries and measures each piece in
- * its own font. That is the whole of what a span costs: the paragraph
- * algorithm is unchanged, and a paragraph with no spans never builds
- * one of these at all.
+ * `line.end` stops at the last glyph, since spaces at a wrap hang and
+ * have no width in layout. The caret still has to move through them,
+ * as it does in a textarea, so geometry measures them from `text`.
  */
-interface SpannedRuns {
-  /** The runs, as the request gave them. */
-  readonly spans: readonly TextRunSpan[];
-  /** Index of the run covering `offset`, or -1 where no run does. */
-  indexAt(offset: number): number;
-  /** The request an offset is measured with: its run's, or the paragraph's. */
-  requestAt(offset: number): TextMeasureRequest;
-  /** Whether the character at `offset` is in a hidden run. */
-  hiddenAt(offset: number): boolean;
-  /** Width of `text.slice(start, end)`, measured run by run. */
-  width(text: string, start: number, end: number): number;
-  /**
-   * Width of a string that is not in the text, in the font of the run
-   * covering `offset`: the ellipsis, and the space a tab is counted
-   * as.
-   */
-  widthOf(run: string, offset: number): number;
-  /**
-   * `text.slice(start, end)` cut at the run boundaries, each piece
-   * placed from `x`. Hidden pieces take no room and are left out.
-   */
-  cut(text: string, start: number, end: number, x: number): TextLineRun[];
-}
+declare function lineLimit(lines: readonly PlacedLine[], index: number, text: string): number;
+/** Where the caret for `offset` is drawn. */
+declare function caretRectFor(lines: readonly PlacedLine[], text: string, offset: number, measure: RunMeasure, rtl: boolean): CaretRect;
+/** The line whose box contains `y`, clamped to the first and last. */
+declare function lineIndexAtY(lines: readonly PlacedLine[], y: number): number;
+/** The caret position nearest to a point: the boundary closest to `x` on the line under `y`. */
+declare function offsetAtPoint(lines: readonly PlacedLine[], text: string, x: number, y: number, measure: RunMeasure, rtl: boolean): number;
 /**
- * Builds the run widths for a request, or undefined when it has no
- * runs.
+ * The caret position on one line nearest to `x`. Widths grow with the
+ * prefix, so the boundary is found by bisection: O(log n) measures per
+ * click on a line of n graphemes.
  *
- * One request object per run, built once: the paragraph cache means a
- * paragraph is laid out once per distinct request, so this runs once
- * per paragraph rather than once per frame.
+ * On the last line the trailing spaces are positions too, so a click
+ * past the text lands after them. On a wrapped line the hanging spaces
+ * are not: a click past the glyphs stops before the break, as it does
+ * in a textarea.
  */
-declare function spannedRunsFor(request: TextMeasureRequest, runs: Pick<TextRunMeasurer, 'measureRunWidth'>): SpannedRuns | undefined;
+declare function offsetAtX(lines: readonly PlacedLine[], index: number, text: string, x: number, measure: RunMeasure, rtl: boolean): number;
 /**
- * Base class for measurers: implement the two primitives and the
- * paragraph algorithm does the rest.
- *
- * **Every paragraph is laid out once per distinct request.** The same
- * request arrives several times a frame and on every frame after: the
- * layout engine asks when it measures the node, and both renderers ask
- * again when they paint it, because a `PaintState` and a box are all a
- * renderer holds. Without a cache a repaint is a line break, and a
- * transition that repaints the whole screen for half a second breaks
- * every paragraph on it sixty times a second. Measured on Sluice's
- * Bluesky feed opening a post: 30 to 50 ms a frame in `segmentParagraph`,
- * `measureRunWidth` and `applySpacing`, against under 13 ms on the same
- * click over short Wikipedia titles. The cache is keyed by every field
- * of the request, so a paragraph that changed in any way is laid out
- * again, and it is least-recently-used with a cap, so a feed that
- * mounts forty new rows a second does not grow it without bound.
- *
- * The result is shared between callers and must not be mutated.
+ * The offset a vertical move lands on: the position nearest the
+ * caret's x (or `goalX`, the x of the line the run of moves started
+ * on) on the adjacent line. Null when there is no line that way, which
+ * callers turn into "go to the start / end of the text".
  */
-declare abstract class ParagraphTextMeasurer implements TextMeasurer, TextRunMeasurer {
-  private readonly paragraphs;
-  abstract measureRunWidth(text: string, request: TextMeasureRequest): number;
-  abstract fontMetrics(request: TextMeasureRequest): FontMetrics;
-  layout(request: TextMeasureRequest): ParagraphLayout;
-  measure(request: TextMeasureRequest): Size;
-  /** How many paragraphs are remembered right now; for specs. */
-  get cachedParagraphs(): number;
-  /**
-   * Forgets every laid-out paragraph. A subclass that caches its own
-   * primitives overrides this and calls it, so a font that finished
-   * loading invalidates the lines as well as the widths they were
-   * built from.
-   */
-  invalidate(): void;
-}
-interface FixedMetricsOptions {
-  /** Advance of every glyph as a fraction of the font size. Default 0.6. */
-  glyphWidth?: number;
-  /** Ascent as a fraction of the font size. Default 0.8. */
-  ascent?: number;
-  /** Descent as a fraction of the font size. Default 0.2. */
-  descent?: number;
-}
+declare function offsetForVerticalMove(lines: readonly PlacedLine[], text: string, offset: number, direction: -1 | 1, measure: RunMeasure, rtl: boolean, goalX?: number): {
+  offset: number;
+  x: number;
+} | null;
 /**
- * Deterministic measurer: every glyph is `glyphWidth` em wide, the
- * font is `ascent + descent` em tall, and the default line is 1.2em.
- *
- * Intended for tests and headless environments. With `glyphWidth: 1`
- * it reproduces the Ahem test font exactly, which is how the layout
- * conformance fixtures compare real wrapping text against Chrome.
+ * The boxes covering `[start, end)`, one per line touched. Hanging
+ * spaces inside the range are highlighted at their width; a line the
+ * range runs past with nothing hanging gets a space's width more, so a
+ * selected line break is visible.
  */
-declare class CharacterCountTextMeasurer extends ParagraphTextMeasurer {
-  private readonly glyphWidth;
-  private readonly ascentFactor;
-  private readonly descentFactor;
-  constructor(options?: FixedMetricsOptions);
-  measureRunWidth(text: string, request: TextMeasureRequest): number;
-  fontMetrics(request: TextMeasureRequest): FontMetrics;
-}
+declare function selectionRects(lines: readonly PlacedLine[], text: string, start: number, end: number, measure: RunMeasure, rtl: boolean): LayoutBox[];
 //#endregion
 //#region src/selection/UiSelectable.d.ts
 /**
@@ -8926,6 +9078,13 @@ declare class EditableLayout {
   readonly placeholderLines: readonly TextLinePlacement[];
   readonly measure: RunMeasure;
   readonly rtl: boolean;
+  /**
+   * The text as drawn: the model's, or a secret field's mask of it
+   * (see `maskText`). The geometry is the drawing's, so it is measured
+   * from this; the two are the same length, so its offsets are the
+   * model's.
+   */
+  readonly text: string;
   constructor(model: EditableTextModel, box: LayoutBox, state: PaintState, measurer: TextMeasurer);
   caretRect(offset?: number): CaretRect;
   /**
@@ -9039,6 +9198,7 @@ declare function editorOf(node: UiNode): EditableTextModel | undefined;
 /** Applies a changed `value` property to the model; see editorFor. */
 declare function syncEditorValue(node: UiNode, model: EditableTextModel): void;
 declare function isEditableNode(node: UiNode): boolean;
+/** Whether Enter inserts a newline. Never in a secret field, which is one line, as a password input is. */
 declare function isMultiline(node: UiNode): boolean;
 declare function isReadOnly(node: UiNode): boolean;
 /**
@@ -10384,6 +10544,11 @@ declare class UiWheelController {
    * wheel of a burst land correctly even though the first could not.
    */
   lastWheelTarget: UiNode | null;
+  /**
+   * The container the wheel last scrolled, for a frame's report of where
+   * scrolling put it. Null until the wheel has scrolled something.
+   */
+  lastScrolled: UiNode | null;
   wheel(x: number, y: number, deltaX: number, deltaY: number, modifiers?: UiKeyModifiers, deltaMode?: UiWheelDeltaMode, wheelDeltaY?: number,
   /**
    * When the event happened, on this controller's clock. Pacing
@@ -10470,16 +10635,15 @@ declare class UiWheelController {
    * comes a varying time after the last step: applied as they arrive, a
    * steady flick moves the page by uneven amounts, which reads as
    * judder. Evening that out by waiting for steps puts the page behind
-   * the hand. So this does what a browser does for its own scrolling:
-   * it puts the page where the input will have reached when the frame is
-   * shown, the steps so far plus their velocity times the time since the
-   * last one, never more than a frame and a half ahead. Steps come out
-   * even, and nothing trails.
+   * the hand. So this does what a browser does for its own scrolling: it
+   * resamples the steps at the frame's time, reading a line fitted through
+   * the last `VELOCITY_WINDOW_MS` of them. Frames come out even, and
+   * nothing trails.
    *
-   * A gesture's first step, with no velocity yet, goes as it is. Once the
-   * steps stop, the prediction is withdrawn and the page settles exactly
-   * where they add up to; a trackpad's momentum slows to nothing first,
-   * so there is next to nothing to withdraw.
+   * A gesture's first step, with no line yet, goes as it is. Once the
+   * steps stop, the page eases over a few frames to exactly where they add
+   * up to; a trackpad's momentum slows to nothing first, so there is next
+   * to nothing to take up.
    *
    * True while a gesture is still being paced, so the host keeps frames
    * coming until it has settled.
@@ -11454,6 +11618,14 @@ interface EditingState {
    * `UiEditingGroup.copyHtml`). Absent otherwise.
    */
   readonly html?: string;
+  /**
+   * A secret field (`UiProperties.secret`). `text` is then its mask,
+   * not its value, so the value never leaves the runtime; `clipboard`
+   * is empty, so a copy or a cut takes nothing. A shell edits it
+   * through a password input, which is what tells the platform not to
+   * learn, correct or read out what is typed.
+   */
+  readonly secret?: true;
 }
 interface EditingControllerOptions {
   /** Keyboard conventions; detected from the user agent by default. */
@@ -12169,6 +12341,8 @@ interface UiHostFrameClockOptions {
    * turn out to be worse than its host's.
    */
   requestAnimationFrame?: ((callback: (time: number) => void) => number) | null;
+  /** This thread's `performance.timeOrigin`, to read the host's times on this clock. Injectable for specs. */
+  timeOrigin?: number;
   /** How long to wait for a host tick before pacing a frame anyway. */
   fallbackMs?: number;
   /**
@@ -12246,14 +12420,104 @@ declare class UiHostFrameClock implements UiFrameClock {
   private readonly minStallMs;
   private readonly now;
   /** This thread's own `requestAnimationFrame`, or null where there is none. */
-  private readonly local;
+  private local;
   private localHandle;
+  /** Whether the page is hidden, when this thread's refreshes do not come. */
+  private hidden;
+  private readonly timeOrigin;
+  /** Gaps between this thread's own refreshes while frames ran back to back. */
+  private readonly localIntervals;
+  private lastLocalTime;
+  /** The display's interval and the host's time origin, once the host has said. */
+  private display;
+  /**
+   * Set once this thread's refreshes have shown they keep no display's
+   * time: frames are then timed here, on the beat the host's refreshes
+   * show (see \`displayInterval\`).
+   */
+  private locked;
+  /** The host's recent refresh times, which give the beat its phase. */
+  private readonly refreshes;
+  /** Host refreshes since the last frame drawn on the beat. */
+  private refreshesSinceFrame;
+  /** The refresh the last frame here was drawn for: a frame is never drawn for one twice. */
+  private lastLocked;
+  /** How long recent frames took here, which decides how many refreshes each one gets. */
+  private readonly costs;
+  /** Refreshes per frame on the beat: 1, or more when frames cost more than a refresh can hold. */
+  private stride;
   constructor(onFrame: (time: UiFrameTime) => void,
   /** Told when this starts and stops wanting ticks. */
   onActive: (active: boolean) => void, options?: UiHostFrameClockOptions);
   /** Whether this clock is driving itself from the compositor. */
   get isLocal(): boolean;
   requestFrame(): void;
+  /**
+   * The page was hidden or shown. While it is hidden this thread's own
+   * refreshes stop, so a frame asked for is paced by the timer, as a
+   * hosted clock is when its host stops ticking; one already waiting
+   * for a refresh that will not come is handed to the timer.
+   */
+  setHidden(hidden: boolean): void;
+  /**
+   * Tells the clock the display's interval, measured on the host's own
+   * refreshes, and the host's \`timeOrigin\`, which puts the host's frame
+   * times on this thread's clock.
+   *
+   * A worker's own refreshes are not always the display's. WebKit's come
+   * from a timer near 65 Hz that keeps no display's time: on a 120 Hz
+   * MacBook its frames fell 15 to 16.4 ms apart, so each was shown after
+   * one refresh, two or three, and a scroll juddered at a steady sixty.
+   * Driving frames from the host's ticks instead put the host's thread in
+   * every frame, and WebKit's is uneven while scrolling: at 120 a seventh
+   * of the frames missed their refresh. So once this thread's refreshes
+   * have shown they keep no display's time, frames follow the host's
+   * refreshes, which are the only ones a worker's canvas is shown on in
+   * WebKit anyway, with two differences from a plain hosted clock: each
+   * frame is stamped with its refresh on the display's beat and on this
+   * thread's clock, which is the clock a wheel step's time is on; and
+   * frames too costly for one refresh are given an even two (see
+   * \`recordCost\`).
+   */
+  displayInterval(ms: number, origin: number): void;
+  /** Whether frames are timed here on the display's beat; see \`displayInterval\`. */
+  get isDisplayLocked(): boolean;
+  private recordLocal;
+  /**
+   * Gives this thread's refreshes up when they come well slower than the
+   * display's: they cost frames, and in WebKit keep no display's beat
+   * either. Faster than the display is left alone, because that is the
+   * display the measurement was taken on going stale (a window dragged to
+   * a faster screen), not a worker failing to keep up with it.
+   */
+  private compareLocal;
+  /** A time on the host's clock, on this thread's. */
+  private toLocal;
+  /**
+   * When the display's refreshes start, on the host's clock: the earliest
+   * in phase of the host's recent refresh times, since a host's callback
+   * can only run late, never early.
+   */
+  private beat;
+  /** The interval between the most punctual early and late refreshes, judged by `rough`. */
+  private refineInterval;
+  /**
+   * Draws the frame a host refresh asked for, stamped with that refresh on
+   * the display's beat rather than with when its callback happened to run,
+   * and on this thread's clock.
+   */
+  private deliverOnBeat;
+  /**
+   * Keeps the stride to what frames cost: every refresh while the typical
+   * frame fits in most of one, two once it no longer does. Decided by the
+   * typical frame, not the slow ones: a slow frame (a few rows mounted at
+   * once) shown a refresh late is a moment's hitch, where two refreshes a
+   * frame for a whole scroll halves the rate. Ruled by the slow quarter,
+   * a 165 Hz display drew at 82 with its typical frame in half a refresh.
+   */
+  private recordCost;
+  /** Refreshes per frame while timed on the display's beat; see \`recordCost\`. */
+  get displayStride(): number;
   /**
    * Arms the timer that draws a frame the host did not ask for.
    *
@@ -12691,6 +12955,8 @@ declare class LayoutEngine {
    */
   private readonly stickyShifted;
   private readonly textMeasurer;
+  /** Where `measureLeaf` resolves a text node's font; read before anything else can resolve one. */
+  private readonly fontScratch;
   /**
    * The definite size percentages resolve against while a container's
    * children are measured: its content box. Undefined on an axis whose
@@ -13742,7 +14008,10 @@ declare const ELLIPSIS = "…";
  * narrower than the widest segment. When a segment is wider than the
  * available width the paragraph grows to it, and every line wraps
  * against that grown width rather than the one asked for, because that
- * is the box the lines will be painted in.
+ * is the box the lines will be painted in. When the width is the box's
+ * own (`exactWidth`: a width set from outside, or the box being
+ * painted), it does not grow: the lines wrap against it and the wide
+ * segment overflows alone, as CSS wraps text in a box of a fixed width.
  *
  * The first baseline sits half the leading below the line top, plus the
  * ascent, with the half-leading floored to a whole pixel. That floor is
@@ -16028,26 +16297,33 @@ interface UiRenderer {
  * subtree changed.
  *
  * **When one is trusted.** Only when the caller vouches for what
- * changed (`RenderContext.changes`), and only while all of these hold:
- *
- *   - no box moved anywhere (`geometryVersion` is unchanged), and the
- *     frame dirtied nothing but paint, scroll and semantics;
- *   - nothing in the container's subtree, and none of its ancestors,
- *     was dirtied, except the container's own scroll offset — an
- *     ancestor because inherited paint (a text colour, a font) reaches
- *     the subtree without dirtying it, and because the runtime marks
- *     the root to ask for a repaint and says nothing about what for;
+ * changed (\`RenderContext.changes\`), and only while all of these hold:
+ *
+ *   - no ancestor's properties or environment changed: an inherited
+ *     value set above marks the descendants that read it, which is
+ *     damage like any other, and this keeps the old caution for the
+ *     rest. An ancestor marked for paint alone is the runtime asking
+ *     for a frame; one laid out again either leaves the container where
+ *     it was or moves it, which the next rule hears about;
  *   - the container lands on the same device-pixel phase, at the same
  *     device scale, with no rotation, skew or scale above it and no
  *     opacity in force, so a copy is exact rather than resampled;
- *   - the scroll moved it by a whole number of device pixels;
  *   - nothing the layer drew depends on the clock (a caret, a fading
  *     scrollbar, a video frame) or escaped it (a lifted node).
  *
+ * **What a frame redraws in it.** The strip a scroll brought into view
+ * (the scroll as the frame draws it, snapped to a device pixel), and the
+ * items something changed (see \`damage\`): an item, one of the
+ * container's children through any fragments, is wrong where it was and
+ * where it is when it is added, removed, moved, or changed inside. A
+ * lazy list scrolling mounts and unmounts rows in its overscan and grows
+ * and shrinks spacers off screen, so what it redraws is the strip. Only
+ * what reaches the strips is walked, a \`SPILL\` past them.
+ *
  * Anything else, and the container is drawn directly, exactly as it
  * was before layers existed. The first frame a container scrolls on
  * pays for the layer — its content drawn into it, then the copy onto
- * the frame — and every scroll-only frame after that is repaid.
+ * the frame — and every frame after that is repaid.
  *
  * **What it cannot help.** A frame where the content itself changes —
  * a live layer redrawn every tick, a zoom that resizes every tile — is
@@ -16069,6 +16345,67 @@ interface ScrollLayerStats {
   dropped: number;
 }
 //#endregion
+//#region src/rendering/canvas2d/TextRasterCache.d.ts
+/**
+ * Text kept as pixels, so a frame that only moved it copies it rather
+ * than drawing its glyphs again.
+ *
+ * **Why.** Drawing glyphs is most of what a frame of text costs:
+ * profiled while flicking through a file in Easel, `fillText` was 1,064
+ * of the renderer's 1,985 ms. A scroll moves every line on screen and
+ * changes none of them, so every one of those glyphs was drawn again
+ * only to land a few pixels from where it was. In WKWebView a frame of
+ * that cost 4 to 7 ms, which is more than a 165 Hz refresh holds.
+ *
+ * **What is kept.** What `drawText` draws for one node, drawn once into
+ * a canvas of its own at the device scale and fraction of a pixel it
+ * lands on, and copied onto the frame from then on. The copy lands on
+ * whole device pixels, so the pixels are the ones a direct draw at that
+ * fraction would have made, and a scroll, which moves by whole device
+ * pixels, keeps the fraction.
+ *
+ * **When it is drawn again.** When anything `drawText` reads changes:
+ * the text, its runs, its font, its colour, its box, the scale, or the
+ * fraction of a pixel it sits at. Each is compared every frame, which is
+ * a few comparisons; a run list or a colour that has not changed is the
+ * same object it was.
+ *
+ * **What it is not for.** Text that changes on most frames (a clock, a
+ * counter, an animated colour) would be drawn twice a frame, into the
+ * cache and out of it. A node redrawn on most of its recent frames is
+ * drawn directly instead, until it has been still for a while.
+ */
+declare class TextRasterCache {
+  private readonly createCanvas;
+  private readonly entries;
+  private frame;
+  private pixels;
+  /** Draws served from the cache and drawn into it, since the last reset. For budget specs. */
+  readonly stats: {
+    copied: number;
+    drawn: number;
+    direct: number;
+  };
+  constructor(createCanvas: LayerCanvasFactory);
+  beginFrame(): void;
+  /** Lets go of text not drawn lately: removed, scrolled far away, or hidden. */
+  endFrame(): void;
+  dropAll(): void;
+  resetStats(): void;
+  /**
+   * Draws a node's text from the cache, drawing it into the cache first
+   * when what it holds is out of date. False when the text should be
+   * drawn directly: a context that cannot say where it draws, one that
+   * rotates or skews, text too large to keep, or text that changes too
+   * often to be worth keeping.
+   */
+  draw(ctx: Canvas2DContext, node: UiNode, box: LayoutBox, paint: PaintState, measurer: TextMeasurer): boolean;
+  private redraw;
+  /** Makes room for `needed` more pixels, letting go of what was drawn least recently. */
+  private make;
+  private drop;
+}
+//#endregion
 //#region src/rendering/canvas2d/Canvas2DRenderer.d.ts
 interface Canvas2DRendererOptions {
   /**
@@ -16091,10 +16428,16 @@ interface Canvas2DRendererOptions {
    */
   scrollLayers?: boolean;
   /**
-   * Makes the canvases scroll layers are kept in. Defaults to an
-   * `OffscreenCanvas`; a spec passes a double.
+   * Makes the canvases scroll layers and kept text are held in. Defaults
+   * to an `OffscreenCanvas`; a spec passes a double.
    */
   createLayerCanvas?: LayerCanvasFactory;
+  /**
+   * Whether text is kept as pixels across frames and copied rather than
+   * drawn again while it has not changed. Defaults to true; false draws
+   * every glyph every frame, as before. See `TextRasterCache.ts`.
+   */
+  textCache?: boolean;
   /**
    * How many frames in a row a container must scroll quietly before it
    * gets a layer. Defaults to `SCROLL_LAYER_SETTLE_FRAMES`; a spec of
@@ -16205,6 +16548,10 @@ declare class Canvas2DRenderer implements UiRenderer {
    */
   private volatileDraws;
   constructor(options: Canvas2DRendererOptions);
+  /** Text kept as pixels; see `TextRasterCache.ts`. */
+  private readonly textCache;
+  /** What the text cache did since the last reset, or null with it off. For budget specs. */
+  get textCacheStats(): TextRasterCache['stats'] | null;
   /** What the scroll layers did since the last reset. For budget specs. */
   get scrollLayerStats(): ScrollLayerStats;
   resetScrollLayerStats(): void;
@@ -19047,5 +19394,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp4AudioTrack as $, UiDroppedFile as $a, Responsive as $c, editableSpansOf as $d, UiBoxShadow as $f, cubicBezier as $g, colorsEqualPalette as $h, AxisExplanation as $i, UiPropertyName as $l, NodeId as $m, ScrollOffset as $n, scrollbarThumbs as $o, UiPropValue as $p, clickOutside as $r, PaintState as $s, registerFontStack as $t, UiThemeExtensionOptions as $u, offsetAtPointIn as A, resolveCursor as Aa, TextRunSpan as Ac, UiLayoutChild as Ad, UiRadialGradient as Af, defaultMotion as Ag, UiTextAlign as Ah, propertyValuesEqualByName as Ai, ContainerProps as Al, MotionStateInput as Am, LABEL_PADDING_X as An, overrideSources as Ao, UiModifierEnvironment as Ap, ImageResolver as Ar, CanvasTextStyle as As, createTextCache as At, LazyAxis as Au, markNow as B, touchActionFor as Ba, lineLimit as Bc, UiFontKerning as Bd, UiLength as Bf, transformIsIdentity as Bg, borderRadiusCorners as Bh, parseAlignContent as Bi, PaintProps as Bl, slideFrom as Bm, resolvePropertyByName as Bn, HitTestResult as Bo, UiModifierHost as Bp, ZoomState as Br, layoutTextLines as Bs, isWebGPUAvailable as Bt, VirtualUpdate as Bu, hasTextLinks as C, isNodeFocusable as Ca, SpannedRuns as Cc, UiTypography as Cd, MAX_GRADIENT_STOPS as Cf, UiTweenOptions as Cg, UiObjectFit as Ch, findPropertyDefinition as Ci, UiChildrenBinding as Cl, noKeyModifiers as Cm, LayerCanvasFactory as Cn, UiGestureRecognizer as Co, UiEditingGroup as Cp, IconContext as Cr, syncEditorValue as Cs, RenderList as Ct, SheetRowRenderer as Cu, setLinkHover as D, isNodeTabStop as Da, TextMeasurer as Dc, isTypographyRole as Dd, UiGradientOffset as Df, UiMotion as Dg, UiPosition as Dh, propertyEffects as Di, ButtonProps as Dl, MOTION_REST as Dm, LayoutReader as Dn, NodeTransitions as Do, comparePositions as Dp, iconKey as Dr, detectEditingPlatform as Ds, TEXTURED_STRIDE_FLOATS as Dt, UiVirtualSheetOptions as Du, linkRunAtPointIn as E, isNodeSelectable as Ea, TextMeasureRequest as Ec, defaultTypography as Ed, UiGradient as Ef, UiEasingToken as Eg, UiPointerEvents as Eh, inheritedPropertyNames as Ei, BoxProps as El, MOTION_CHANNELS as Em, UiRenderer as En, FocusNotifier as Eo, adjacentField as Ep, IconSpec as Er, commandForKey as Es, TEXTURED_STRIDE_BYTES as Et, UiVirtualSheet as Eu, UiFrameCallback as F, UiPlatformAdapter as Fa, PlacedLine as Fc, UiVisualStateSet as Fd, validateGradient as Ff, interpolatorFor as Fg, UiVerticalAlign as Fh, placeGridItems as Fi, GridItemProps as Fl, pop as Fm, CanvasSurface as Fn, UiFindController as Fo, assertModifierList as Fp, ShortcutsOptions as Fr, applyCanvasTextStyle as Fs, GlyphSlot as Ft, UiVirtualWindow as Fu, VttTrack as G, TouchScrollerOptions as Ga, graphemeBoundaries as Gc, UiSpannedText as Gd, isFrLength as Gf, colorToRgba as Gg, uniformBorderRadius as Gh, ELLIPSIS as Gi, ScrollViewProps as Gl, LayoutBox as Gm, InsetPaddingArgs as Gn, SCROLLBAR_INSET as Go, ComponentResolver as Gp, ReorderableOptions as Gr, Canvas2DContext as Gs, WebGPURenderer as Gt, videoFrameSize as Gu, performanceMarksEnabled as H, EditingHost as Ha, offsetAtX as Hc, UiFontStyle as Hd, auto as Hf, UiBasicColors as Hg, borderRadiusIsZero as Hh, parseMainAxisAlignment as Hi, PropsOf as Hl, SharedClaim as Hm, ThemeTokenTarget as Hn, UiHitTester as Ho, FocusOptions as Hp, AutoScrollOptions as Hr, runFontString as Hs, CapturedFrame as Ht, lazySource as Hu, UiScheduler as I, capturePointer as Ia, RunMeasure as Ic, defaultVisualState as Id, AutoLength as If, UiTransform as Ig, validateSubgrid as Ih, sizeGridTracks as Ii, GridProps as Il, resolveMotionState as Im, createCanvasSurface as In, SelectionControllerOptions as Io, UiModifier as Ip, contextMenu as Ir, buildFontString as Is, GlyphUpload as It, VIRTUAL_INDEX_PROP as Iu, ByteSource as J, UiDragPayload as Ja, nextGraphemeEnd as Jc, UiTextMetrics as Jd, minmax as Jf, normalizeColor as Jg, UiShapes as Jh, LayoutNotifier as Ji, TextProps as Jl, Size as Jm, publishInset as Jn, ScrollbarAxis as Jo, UiElement as Jp, reorderable as Jr, DEFAULT_FONT_SIZE as Js, WebGPUSurface as Jt, lightTheme as Ju, cueAt as K, UiTouchScroller as Ka, lineEndAt as Kc, UiTextDecoration as Kd, isMinMaxTrack as Kf, colorValuesEqual as Kg, UiShapeExtensions as Kh, layoutParagraph as Ki, StackProps as Kl, LayoutResult as Km, PublishInsetArgs as Kn, SCROLLBAR_MIN_THUMB as Ko, ComponentLikeElement as Kp, dragSource as Kr, Canvas2DGradient as Ks, WebGPURendererOptions as Kt, UiTheme as Ku, UiSchedulerOptions as L, isImeKey as La, caretRectFor as Lc, hasVisualState as Ld, FrLength as Lf, UiTransforms as Lg, UiBorderRadius as Lh, AlignContent as Li, IdentityProps as Ll, rotateFrom as Lm, resolveBoolean as Ln, SelectionHost as Lo, UiModifierKind as Lp, shortcut as Lr, createCanvasTextStyle as Ls, WebGPUGlyphAtlas as Lt, VIRTUAL_LEAD_PROP as Lu, paragraphGeometryFrom as M, PlatformAdapterOptions as Ma, TextWrap as Mc, UiLayoutProtocol as Md, gradientsEqual as Mf, interpolateColor as Mg, UiTextOverflowValue as Mh, GridItemRequest as Mi, EnvironmentProps as Ml, ResolvedMotionState as Mm, drawOverlayShapes as Mn, writeDeclaredProperty as Mo, UiModifierLayout as Mp, animateLayout as Mr, SpanPaint as Ms, textRuns as Mt, LazyItemRenderer as Mu, selectionRectsIn as N, PlatformEventTarget as Na, spannedRunsFor as Nc, isLayoutProtocol as Nd, linearGradient as Nf, interpolateNumber as Ng, UiTextWrapValue as Nh, GridPlacement as Ni, FlexContainerProps as Nl, fade as Nm, labelOrigin as Nn, writeOverrideProperty as No, UiModifierSet as Np, ContextMenuOptions as Nr, TextLinePlacement as Ns, GlyphShaper as Nt, LazyListOptions as Nu, ParagraphGeometry as O, isSubtreeInert as Oa, TextOverflow as Oc, typographyEqual as Od, UiGradientStop as Of, UiSpringSpec as Og, UiSelfAlignment as Oh, propertyIsInherited as Oi, ColumnProps as Ol, MotionChannel as Om, RenderChanges as On, resetTransitionWarnings as Oo, edgeField as Op, DefaultImageResolver as Or, isPrintable as Os, TextRunDraw as Ot, VIRTUAL_SHEET_PROP as Ou, wordRangeIn as P, PlatformSurface as Pa, CaretRect as Pc, UiVisualState as Pd, radialGradient as Pf, interpolateTransform as Pg, UiThemeColorName as Ph, GridTrack as Pi, FlexItemProps as Pl, isMotionRest as Pm, CanvasHost as Pn, FindHost as Po, UiUnknownModifierPropertyError as Pp, ShortcutOptions as Pr, TextRunRect as Ps, GLYPH_SUBPIXEL_PHASES as Pt, LazySourceArgs as Pu, rangeSource as Q, UiDropZone as Qa, wordRangeAt as Qc, defaultTextStyle as Qd, BOX_SHADOW_BLUR_REACH as Qf, UiEasing as Qg, UiColors as Qh, ScrollAdjustment as Qi, UiProperties as Ql, tightenConstraints as Qm, sizeContainer as Qn, scrollbarThumb as Qo, isUiElement as Qp, ClickOutsideOptions as Qr, PaintBoxShadow as Qs, fontStackFor as Qt, UiThemeExtension as Qu, MARK_PREFIX as R, pointerDeviceOf as Ra, lineIndexAtY as Rc, visualState as Rd, MinMaxTrack as Rf, parseTransform as Rg, UiBorderRadiuses as Rh, CrossAxisAlignment as Ri, InteractionProps as Rl, scaleFrom as Rm, resolveNumber as Rn, UiSelectionController as Ro, defineModifier as Rp, shortcuts as Rr, drawText as Rs, WebGPUTextureCache as Rt, VIRTUAL_WINDOW_PROP as Ru, clearLinkHover as S, UiTimerFrameClockOptions as Sa, ParagraphTextMeasurer as Sc, shadowsEqual as Sd, GradientPaint as Sf, UiTween as Sg, UiGridAutoFlow as Sh, closestPropertyName as Si, ChildrenBindingId as Sl, UiWheelEvent as Sm, traceRoundedRect as Sn, GestureRecognizerOptions as So, textInputOf as Sp, IconCanvas as Sr, nextCaretToggle as Ss, RenderCommand as St, SheetRange as Su, linkOf as T, isNodeInert as Ta, TextLineRun as Tc, UiTypographyRole as Td, ResolvedGradientStop as Tf, UiDurationToken as Tg, UiPlacement as Th, inheritedPropertyFlags as Ti, BoxModelProps as Tl, DirtyNodeSet as Tm, RendererBackend as Tn, UiPinchRecognizer as To, UiTextPosition as Tp, IconRasterizerOptions as Tr, EditingPlatform as Ts, ScissorRect as Tt, SheetViewport as Tu, setPerformanceMarks as U, EditingState as Ua, offsetForVerticalMove as Uc, UiFontVariant as Ud, fr as Uf, UiColor as Ug, borderRadiusValuesEqual as Uh, FlexDirection as Ui, Reactive as Ul, UiSharedElements as Um, themeTokens as Un, UiPoint as Uo, FocusSource as Up, DragSourceOptions as Ur, textRunBackgrounds as Us, DrawStats as Ut, UiVideoSurface as Uu, measureSpan as V, EditingControllerOptions as Va, offsetAtPoint as Vc, UiFontStretch as Vd, UiTrackSize as Vf, transformsEqual as Vg, borderRadiusEqual as Vh, parseCrossAxisAlignment as Vi, PositionProps as Vl, slideUp as Vm, resolveString as Vn, HitTester as Vo, UiModifierTeardown as Vp, pinchable as Vr, runCanvasStyleInto as Vs, WebGPUError as Vt, VirtualViewport as Vu, VttCue as W, UiEditingController as Wa, selectionRects as Wc, UiResolvedTextSpan as Wd, isAutoLength as Wf, colorToHex as Wg, normalizeBorderRadius as Wh, parseFlexDirection as Wi, RowProps as Wl, Constraints as Wm, sameArgs as Wn, SCROLLBAR_HOVER_ZONE as Wo, UiFocusManager as Wp, DropTargetOptions as Wr, textRunDecorations as Ws, RenderHooks as Wt, isVideoSurface as Wu, RangeSourceOptions as X, UiDragState as Xa, previousGraphemeStart as Xc, UiTextSpan as Xd, repeat as Xf, rgb8 as Xg, isShapeName as Xh, SCROLLBAR_FADE_MS as Xi, UiEventProps as Xl, clampSize as Xm, SizeContainerArgs as Xn, scrollLeaderOf as Xo, isObservable$1 as Xp, DraggableOptions as Xr, DEFAULT_TEXT_COLOR as Xs, bumpFontStack as Xt, withContrast as Xu, DEFAULT_BLOCK_SIZE as Y, UiDragSession as Ya, nextWordEnd as Yc, UiTextRange as Yd, percent as Yf, parseColor as Yg, defaultShapes as Yh, LayoutEngine as Yi, TypographyProps as Yl, TightenOptions as Ym, BreakpointArgs as Yn, ScrollbarThumb as Yo, isComponentLikeElement as Yp, DragOffset as Yr, DEFAULT_FONT_WEIGHT as Ys, createWebGPUSurface as Yt, themesEqual as Yu, bufferSource as Z, UiDropEffect as Za, previousWordStart as Zc, UiTextStyle as Zd, resolveLength as Zf, rgba as Zg, shapesEqual as Zh, SCROLLBAR_LINGER_MS as Zi, UiNodeRef as Zl, constraintsEqual as Zm, breakpoint as Zn, scrollRange as Zo, isUiChild as Zp, draggable as Zr, ObjectFit as Zs, clearFontStacks as Zt, withDensity as Zu, buildSemanticsTree as _, UiFrameTime as _a, setSelectionRange as _c, scaleSpacing as _d, UiPath as _f, UiAnimation as _g, UiContentDistribution as _h, bundle as _i, UiDefinition as _l, UiPointerEvent as _m, LayoutInspector as _n, UiScrollBehavior as _o, bandOf as _p, IconSourceArgs as _r, editorFor as _s, INSTANCE_STRIDE_FLOATS as _t, EditUnit as _u, diffSemantics as a, RelayoutExplanation as aa, createPaintState as ac, themeExtensionsEqual as ad, spansDifferOnlyInPaint as af, createEnvironmentKey as ag, DecorationFill as ah, borderShapes as ai, LazyRow as al, MOUSE_POINTER as am, PaintContext2D as an, UiShortcutRegistry as ao, UiPropertyDefinition as ap, VideoTransport as ar, setMatchRanges as as, Mp3Frame as at, UiLiveRegion as au, semanticsMemory as b, UiManualFrameClock as ba, FontMetrics as bc, UiShadows as bd, pathValuesEqual as bf, UiSpring as bg, UiFlexWrap as bh, accumulatedOffsetTo as bi, UiGraph as bl, UiTextChangeEvent as bm, Canvas2DRenderer as bn, isScrollContainer as bo, UiTextInput as bp, iconSource as br, isMultiline as bs, PrimitiveCommand as bt, LazySheetProps as bu, SemanticsMemory as c, describeOverrides as ca, normalizeVerticalAlign as cc, UiContrast as cd, textStylesEqual as cf, DirtyFlags as cg, DecorationStroke as ch, focusRing as ci, Column as cl, UiEventType as cm, PaintTarget as cn, formatShortcut as co, UiInsetEdge as cp, DefaultVideoResolverOptions as cr, findMatchesIn as cs, readMp3Header as ct, UiSemanticState as cu, SemanticsRewalk as d, labelNode as da, TEXT_SELECTION_PROP as dc, raiseContrast as dd, PaintLineCap as df, UiTransitionValue as dg, hasDecorationPhase as dh, hoverable as di, Paint as dl, UiInputEvent as dm, PaintOp as dn, KeyboardControllerOptions as do, UiInsets as dp, VideoResolver as dr, UiEnvironmentKeys as ds, Affine as dt, isUiSemanticState as du, easings as e_, CustomLayoutExplanation as ea, PaintTextSpan as ec, UiThemeExtensions as ed, flattenTextSpans as ef, darkColors as eg, NodeProperty as eh, autoFocus as ei, ResponsiveProps as el, UiProps as em, PaintCanvas as en, UiFileDropMessage as eo, boxShadow as ep, ScrollPositionArgs as er, scrollbarZoneAt as es, Mp4Sample as et, UiPropertyValueOf as eu, SemanticsSpan as f, withOverrideSource as fa, TextRange as fc, relativeLuminance as fd, PaintLineJoin as ff, assertTransitionMap as fg, paintsAfterChildren as fh, interactive as fi, Row as fl, UiKeyModifiers as fm, PaintRecorder as fn, UiKeyboardController as fo, insetsEqual as fp, canDecodeVideo as fr, EnvironmentNotifier as fs, CLIP_STRIDE_BYTES as ft, normalizeStates as fu, buildSemanticsSubtree as g, UiFrameClockFactory as ga, selectionRangeOf as gc, defaultSpacing as gd, UiPaint as gf, AnimatedCell as gg, UiColorValue as gh, UiModifierBundle as gi, createElement as gl, UiPointerDevice as gm, InspectorOverlay as gn, ScrollSink as go, UiContainerSizeSource as gp, sharedElement as gr, caretVisibleAt as gs, INSTANCE_STRIDE_BYTES as gt, CompositionRange as gu, UiSemanticsRecord as h, UiFrameClock as ha, selectableTextOf as hc, UiSpacing as hd, PaintTextStyle as hf, tween as hg, UiBorderRadiusValue as hh, pressable as hi, Text as hl, UiPinchEvent as hm, INSPECTOR_HEAT_MS as hn, ScrollContainerState as ho, UiContainerSize as hp, motion as hr, EDITOR_PROP as hs, GlyphCommand as ht, validateStates as hu, UiSemanticsPatch as i, OverrideSources as ia, computeObjectFitRect as ic, themeExtension as id, spannedTextOf as if, UiEnvironmentKey as ig, UiPropertyOverrides as ih, FocusRingOptions as ii, LazyListProps as il, UiListenerErrorReporter as im, paintPictures as in, UiShortcutBinding as io, boxShadowsEqual as ip, VideoState as ir, matchRangesOf as is, Mp3Format as it, UiAutocomplete as iu, paragraphGeometry as j, CanvasPlatformSurface as ja, TextRunStyle as jc, UiLayoutContext as jd, gradientPaint as jf, UiInterpolator as jg, UiTextDirection as jh, GridContribution as ji, EditableTextProps as jl, MotionTiming as jm, OverlayShape as jn, resetOverrideWarnings as jo, UiModifierFocus as jp, AnimateLayoutOptions as jr, PlacedTextRun as js, glyphCount as jt, LazyGridOptions as ju, hasDrawnText as k, pointerEventsOf as ka, TextRunMeasurer as kc, MAX_MEASURES_PER_CHILD as kd, UiLinearGradient as kf, UiSpringToken as kg, UiSubgridAxis as kh, propertyNarrowers as ki, CommonProps as kl, MotionState as km, RenderContext as kn, clearOverrideProperty as ko, editingGroupOf as kp, DefaultImageResolverOptions as kr, EditableLayout as ks, buildRenderList as kt, sheetSource as ku, SemanticsPlacement as l, formatConstraints as la, resolvePaintState as lc, contrastRatio as ld, PaintBox as lf, AnimationDriver as lg, decorationColor as lh, BUTTON_INTERACTION as li, EditableText as ll, UiFocusEvent as lm, tracePathData as ln, parseShortcut as lo, UiInsetRegistry as lp, RangeResponse as lr, UiEnvironmentProvider as ls, splitMp3Frames as lt, UiSemanticStates as lu, UiSemanticsMap as m, UiAnimationFrameClock as ma, selectableTextNodes as mc, densityFactors as md, PaintTextAlign as mf, spring as mg, UiAlignment as mh, measureFlow as mi, Stack as ml, UiPasteEvent as mm, replayPaint as mn, UiPointerController as mo, observeViewportInsets as mp, SharedElementArgs as mr, CARET_WIDTH as ms, CommandKind as mt, validateRole as mu, UiSemanticsBox as n, steps as n_, LayoutExplanation as na, VerticalAlign as nc, hasThemeExtension as nd, resolvedSpansOf as nf, LayoutRecord as ng, UiNodeTransitions as nh, BordersOptions as ni, LazyGrid as nl, UiEventListenerOptions as nm, PaintPictureCache as nn, ShortcutRegistryOptions as no, boxShadowRadius as np, VideoClock as nr, TEXT_MATCHES_PROP as ns, demuxMp4Audio as nt, UI_ROLES as nu, dropIndexShifts as o, SizeDecision as oa, isPaintVisible as oc, withThemeExtension as od, textContentOf as of, findEnvironmentKey as og, DecorationRect as oh, borders as oi, Box as ol, UiBeforeInputEvent as om, PaintGradient as on, UiShortcutStep as oo, defineProperty as op, videoSource as or, FindMatch as os, Mp3Frames as ot, UiOrientation as ou, TEXT_RUN_ID_SEPARATOR as p, UiFrame as pa, clearSelectionRange as pc, UiDensity as pd, PaintSurface as pf, normalizeTransition as pg, UI_SUBGRID_AXES as ph, measure as pi, ScrollView as pl, UiKeyboardEvent as pm, PaintRecording as pn, PointerControllerOptions as po, noInsets as pp, MotionArgs as pr, CARET_BLINK_MS as ps, CLIP_STRIDE_FLOATS as pt, statesEqual as pu, parseWebVtt as q, EXTERNAL_FILES as qa, lineStartAt as qc, UiTextLink as qd, isPercentLength as qf, colorsEqual as qg, UiShapeName as qh, proportionalFontMetrics as qi, TextContentProps as ql, LayoutStats as qm, insetPadding as qn, SCROLLBAR_THICKNESS as qo, UiChild as qp, dropTarget as qr, DEFAULT_FONT_FAMILY as qs, WebGPUCanvasHost as qt, darkTheme as qu, UiSemanticsUpdate as r, LayoutStateExplanation as ra, colorToCss as rc, noThemeExtensions as rd, spanAtOffset as rf, UiEnvironment as rg, UiPropertyOverride as rh, Decorations as ri, LazyGridProps as rl, UiInputDispatcher as rm, PaintStats as rn, UiShortcut as ro, boxShadowReach as rp, VideoSourceArgs as rr, clearMatchRanges as rs, demuxMp4Video as rt, UI_SEMANTIC_STATES as ru, recordsEqual as s, describeLength as sa, normalizeTextAlign as sc, HighContrastOptions as sd, textSpansEqual as sf, UiNodeType as sg, DecorationShape as sh, decorated as si, Button as sl, UiCompositionEvent as sm, PaintResolver as sn, describeShortcut as so, propertyValuesEqual as sp, DefaultVideoResolver as sr, FindOptions as ss, Mp3Header as st, UiRole as su, UiSemanticsAction as t, linear as t_, Edges as ta, TextAlign as tc, defineThemeExtension as td, hiddenRangesOf as tf, lightColors as tg, UiNode as th, BorderEdge as ti, LazyColumn as tl, UiEventListener as tm, PaintCanvasFactory as tn, dragSessionFor as to, boxShadowArraysEqual as tp, scrollPosition as tr, SubtreeBounds as ts, Mp4VideoTrack as tt, UiPropertyValues as tu, SemanticsReuse as u, formatExplanation as ua, DEFAULT_LINE_HEIGHT_FACTOR as uc, highContrastColors as ud, PaintFillRule as uf, UiTransitionSpec as ug, decorationRect as uh, InteractiveOptions as ui, Grid as ul, UiGestureEvent as um, EMPTY_RECORDING as un, shortcutKeyCaps as uo, UiInsetSource as up, VideoPlayback as ur, provideEnvironment as us, WebGPUGlyphPages as ut, isUiRole as uu, rewalkSemantics as v, UiHostFrameClock as va, CharacterCountTextMeasurer as vc, spacingEqual as vd, inputsEqual as vf, UiAnimationOptions as vg, UiCursor as vh, noModifiers as vi, BindingId as vl, UiPointerKind as vm, LayoutInspectorOptions as vn, UiScrollability as vo, containerBands as vp, ImageSourceArgs as vr, editorOf as vs, ImageCommand as vt, EditableTextModel as vu, linkHoverOf as w, isNodeHitTestable as wa, TextLine as wc, UiTypographyExtensions as wd, ResolvedGradient as wf, createTween as wg, UiOverflow as wh, getPropertyNames as wi, UiGraphBuilder as wl, wheelDeltaYOf as wm, ScrollLayerStats as wn, PinchRecognizerOptions as wo, UiGroupEdit as wp, IconRasterizer as wr, EditCommand as ws, RenderTextCache as wt, SheetSourceArgs as wu, textRunOfRecordId as x, UiTimerFrameClock as xa, ParagraphLayout as xc, defaultShadows as xd, UiImage as xf, UiSpringOptions as xg, UiFontWeight as xh, contentOffset as xi, UiEventBinding as xl, UiWheelDeltaMode as xm, Canvas2DRendererOptions as xn, GestureInput as xo, UiTextInputState as xp, imageSource as xr, isReadOnly as xs, PrimitiveKind as xt, SheetHeaderRenderer as xu, semanticsInertAbove as y, UiHostFrameClockOptions as ya, FixedMetricsOptions as yc, spacingSteps as yd, paintValuesEqual as yf, UiReducedMotionPolicy as yg, UiDirection as yh, Transform as yi, UiBinding as yl, UiSelectionChangeEvent as ym, CanvasTextMeasurer as yn, UiWheelController as yo, unknownContainerSize as yp, ImageSources as yr, isEditableNode as ys, NO_CLIP_INDEX as yt, LazySheet as yu, markInstant as z, prepareInputSurface as za, lineIndexForOffset as zc, visualStatesEqual as zd, PercentLength as zf, transform as zg, borderRadius as zh, MainAxisAlignment as zi, PaintElementProps as zl, slideDown as zm, resolveProperty as zn, HitTestLayoutReader as zo, isUiModifier as zp, PinchableOptions as zr, fillTextRects as zs, initializeWebGPU as zt, VirtualItemMeasure as zu };
-//# sourceMappingURL=index-8yhrkCnb.d.ts.map
+export { Mp4AudioTrack as $, UiDroppedFile as $a, Text as $c, PaintTextStyle as $d, UiContainerSize as $f, cubicBezier as $g, TextRunSpan as $h, AxisExplanation as $i, validateStates as $l, UiBorderRadiusValue as $m, ScrollOffset as $n, scrollbarThumbs as $o, UiPinchEvent as $p, clickOutside as $r, PaintState as $s, registerFontStack as $t, UiSpacing as $u, offsetAtPointIn as A, resolveCursor as Aa, lineEndAt as Ac, UiTextDecoration as Ad, isMinMaxTrack as Af, defaultMotion as Ag, UiShapeExtensions as Ah, propertyValuesEqualByName as Ai, StackProps as Al, LayoutResult as Am, LABEL_PADDING_X as An, overrideSources as Ao, ComponentLikeElement as Ap, ImageResolver as Ar, CanvasTextStyle as As, createTextCache as At, UiTheme as Au, markNow as B, touchActionFor as Ba, LazyGrid as Bc, resolvedSpansOf as Bd, boxShadowRadius as Bf, transformIsIdentity as Bg, LayoutRecord as Bh, parseAlignContent as Bi, UI_ROLES as Bl, UiNodeTransitions as Bm, resolvePropertyByName as Bn, HitTestResult as Bo, UiEventListenerOptions as Bp, ZoomState as Br, layoutTextLines as Bs, isWebGPUAvailable as Bt, hasThemeExtension as Bu, hasTextLinks as C, isNodeFocusable as Ca, lineIndexForOffset as Cc, visualStatesEqual as Cd, PercentLength as Cf, UiTweenOptions as Cg, borderRadius as Ch, findPropertyDefinition as Ci, PaintElementProps as Cl, slideDown as Cm, LayerCanvasFactory as Cn, UiGestureRecognizer as Co, isUiModifier as Cp, IconContext as Cr, syncEditorValue as Cs, RenderList as Ct, VirtualItemMeasure as Cu, setLinkHover as D, isNodeTabStop as Da, offsetForVerticalMove as Dc, UiFontVariant as Dd, fr as Df, UiMotion as Dg, borderRadiusValuesEqual as Dh, propertyEffects as Di, Reactive as Dl, UiSharedElements as Dm, LayoutReader as Dn, NodeTransitions as Do, FocusSource as Dp, iconKey as Dr, detectEditingPlatform as Ds, TEXTURED_STRIDE_FLOATS as Dt, UiVideoSurface as Du, linkRunAtPointIn as E, isNodeSelectable as Ea, offsetAtX as Ec, UiFontStyle as Ed, auto as Ef, UiEasingToken as Eg, borderRadiusIsZero as Eh, inheritedPropertyNames as Ei, PropsOf as El, SharedClaim as Em, UiRenderer as En, FocusNotifier as Eo, FocusOptions as Ep, IconSpec as Er, commandForKey as Es, TEXTURED_STRIDE_BYTES as Et, lazySource as Eu, UiFrameCallback as F, UiPlatformAdapter as Fa, previousWordStart as Fc, UiTextStyle as Fd, resolveLength as Ff, interpolatorFor as Fg, shapesEqual as Fh, placeGridItems as Fi, UiNodeRef as Fl, constraintsEqual as Fm, CanvasSurface as Fn, UiFindController as Fo, isUiChild as Fp, ShortcutsOptions as Fr, applyCanvasTextStyle as Fs, GlyphSlot as Ft, withDensity as Fu, VttTrack as G, TouchScrollerOptions as Ga, Button as Gc, textSpansEqual as Gd, propertyValuesEqual as Gf, colorToRgba as Gg, ParagraphTextMeasurer as Gh, ELLIPSIS as Gi, UiRole as Gl, DecorationShape as Gm, InsetPaddingArgs as Gn, SCROLLBAR_INSET as Go, UiCompositionEvent as Gp, ReorderableOptions as Gr, Canvas2DContext as Gs, WebGPURenderer as Gt, HighContrastOptions as Gu, performanceMarksEnabled as H, EditingHost as Ha, LazyListProps as Hc, spannedTextOf as Hd, boxShadowsEqual as Hf, UiBasicColors as Hg, FixedMetricsOptions as Hh, parseMainAxisAlignment as Hi, UiAutocomplete as Hl, UiPropertyOverrides as Hm, ThemeTokenTarget as Hn, UiHitTester as Ho, UiListenerErrorReporter as Hp, AutoScrollOptions as Hr, runFontString as Hs, CapturedFrame as Ht, themeExtension as Hu, UiScheduler as I, capturePointer as Ia, wordRangeAt as Ic, defaultTextStyle as Id, BOX_SHADOW_BLUR_REACH as If, UiTransform as Ig, UiColors as Ih, sizeGridTracks as Ii, UiProperties as Il, tightenConstraints as Im, createCanvasSurface as In, SelectionControllerOptions as Io, isUiElement as Ip, contextMenu as Ir, buildFontString as Is, GlyphUpload as It, UiThemeExtension as Iu, ByteSource as J, UiDragPayload as Ja, Grid as Jc, PaintFillRule as Jd, UiInsetSource as Jf, normalizeColor as Jg, TextLineRun as Jh, LayoutNotifier as Ji, isUiRole as Jl, decorationRect as Jm, publishInset as Jn, ScrollbarAxis as Jo, UiGestureEvent as Jp, reorderable as Jr, DEFAULT_FONT_SIZE as Js, WebGPUSurface as Jt, highContrastColors as Ju, cueAt as K, UiTouchScroller as Ka, Column as Kc, textStylesEqual as Kd, UiInsetEdge as Kf, colorValuesEqual as Kg, SpannedRuns as Kh, layoutParagraph as Ki, UiSemanticState as Kl, DecorationStroke as Km, PublishInsetArgs as Kn, SCROLLBAR_MIN_THUMB as Ko, UiEventType as Kp, dragSource as Kr, Canvas2DGradient as Ks, WebGPURendererOptions as Kt, UiContrast as Ku, UiSchedulerOptions as L, isImeKey as La, Responsive as Lc, editableSpansOf as Ld, UiBoxShadow as Lf, UiTransforms as Lg, colorsEqualPalette as Lh, AlignContent as Li, UiPropertyName as Ll, NodeId as Lm, resolveBoolean as Ln, SelectionHost as Lo, UiPropValue as Lp, shortcut as Lr, createCanvasTextStyle as Ls, WebGPUGlyphAtlas as Lt, UiThemeExtensionOptions as Lu, paragraphGeometryFrom as M, PlatformAdapterOptions as Ma, nextGraphemeEnd as Mc, UiTextMetrics as Md, minmax as Mf, interpolateColor as Mg, UiShapes as Mh, GridItemRequest as Mi, TextProps as Ml, Size as Mm, drawOverlayShapes as Mn, writeDeclaredProperty as Mo, UiElement as Mp, animateLayout as Mr, SpanPaint as Ms, textRuns as Mt, lightTheme as Mu, selectionRectsIn as N, PlatformEventTarget as Na, nextWordEnd as Nc, UiTextRange as Nd, percent as Nf, interpolateNumber as Ng, defaultShapes as Nh, GridPlacement as Ni, TypographyProps as Nl, TightenOptions as Nm, labelOrigin as Nn, writeOverrideProperty as No, isComponentLikeElement as Np, ContextMenuOptions as Nr, TextLinePlacement as Ns, GlyphShaper as Nt, themesEqual as Nu, ParagraphGeometry as O, isSubtreeInert as Oa, selectionRects as Oc, UiResolvedTextSpan as Od, isAutoLength as Of, UiSpringSpec as Og, normalizeBorderRadius as Oh, propertyIsInherited as Oi, RowProps as Ol, Constraints as Om, RenderChanges as On, resetTransitionWarnings as Oo, UiFocusManager as Op, DefaultImageResolver as Or, isPrintable as Os, TextRunDraw as Ot, isVideoSurface as Ou, wordRangeIn as P, PlatformSurface as Pa, previousGraphemeStart as Pc, UiTextSpan as Pd, repeat as Pf, interpolateTransform as Pg, isShapeName as Ph, GridTrack as Pi, UiEventProps as Pl, clampSize as Pm, CanvasHost as Pn, FindHost as Po, isObservable$1 as Pp, ShortcutOptions as Pr, TextRunRect as Ps, GLYPH_SUBPIXEL_PHASES as Pt, withContrast as Pu, rangeSource as Q, UiDropZone as Qa, Stack as Qc, PaintTextAlign as Qd, observeViewportInsets as Qf, UiEasing as Qg, TextRunMeasurer as Qh, ScrollAdjustment as Qi, validateRole as Ql, UiAlignment as Qm, sizeContainer as Qn, scrollbarThumb as Qo, UiPasteEvent as Qp, ClickOutsideOptions as Qr, PaintBoxShadow as Qs, fontStackFor as Qt, densityFactors as Qu, MARK_PREFIX as R, pointerDeviceOf as Ra, ResponsiveProps as Rc, flattenTextSpans as Rd, boxShadow as Rf, parseTransform as Rg, darkColors as Rh, CrossAxisAlignment as Ri, UiPropertyValueOf as Rl, NodeProperty as Rm, resolveNumber as Rn, UiSelectionController as Ro, UiProps as Rp, shortcuts as Rr, drawText as Rs, WebGPUTextureCache as Rt, UiThemeExtensions as Ru, clearLinkHover as S, UiTimerFrameClockOptions as Sa, lineIndexAtY as Sc, visualState as Sd, MinMaxTrack as Sf, UiTween as Sg, UiBorderRadiuses as Sh, closestPropertyName as Si, InteractionProps as Sl, scaleFrom as Sm, traceRoundedRect as Sn, GestureRecognizerOptions as So, defineModifier as Sp, IconCanvas as Sr, nextCaretToggle as Ss, RenderCommand as St, VIRTUAL_WINDOW_PROP as Su, linkOf as T, isNodeInert as Ta, offsetAtPoint as Tc, UiFontStretch as Td, UiTrackSize as Tf, UiDurationToken as Tg, borderRadiusEqual as Th, inheritedPropertyFlags as Ti, PositionProps as Tl, slideUp as Tm, RendererBackend as Tn, UiPinchRecognizer as To, UiModifierTeardown as Tp, IconRasterizerOptions as Tr, EditingPlatform as Ts, ScissorRect as Tt, VirtualViewport as Tu, setPerformanceMarks as U, EditingState as Ua, LazyRow as Uc, spansDifferOnlyInPaint as Ud, UiPropertyDefinition as Uf, UiColor as Ug, FontMetrics as Uh, FlexDirection as Ui, UiLiveRegion as Ul, DecorationFill as Um, themeTokens as Un, UiPoint as Uo, MOUSE_POINTER as Up, DragSourceOptions as Ur, textRunBackgrounds as Us, DrawStats as Ut, themeExtensionsEqual as Uu, measureSpan as V, EditingControllerOptions as Va, LazyGridProps as Vc, spanAtOffset as Vd, boxShadowReach as Vf, transformsEqual as Vg, CharacterCountTextMeasurer as Vh, parseCrossAxisAlignment as Vi, UI_SEMANTIC_STATES as Vl, UiPropertyOverride as Vm, resolveString as Vn, HitTester as Vo, UiInputDispatcher as Vp, pinchable as Vr, runCanvasStyleInto as Vs, WebGPUError as Vt, noThemeExtensions as Vu, VttCue as W, UiEditingController as Wa, Box as Wc, textContentOf as Wd, defineProperty as Wf, colorToHex as Wg, ParagraphLayout as Wh, parseFlexDirection as Wi, UiOrientation as Wl, DecorationRect as Wm, sameArgs as Wn, SCROLLBAR_HOVER_ZONE as Wo, UiBeforeInputEvent as Wp, DropTargetOptions as Wr, textRunDecorations as Ws, RenderHooks as Wt, withThemeExtension as Wu, RangeSourceOptions as X, UiDragState as Xa, Row as Xc, PaintLineJoin as Xd, insetsEqual as Xf, rgb8 as Xg, TextMeasurer as Xh, SCROLLBAR_FADE_MS as Xi, normalizeStates as Xl, paintsAfterChildren as Xm, SizeContainerArgs as Xn, scrollLeaderOf as Xo, UiKeyModifiers as Xp, DraggableOptions as Xr, DEFAULT_TEXT_COLOR as Xs, bumpFontStack as Xt, relativeLuminance as Xu, DEFAULT_BLOCK_SIZE as Y, UiDragSession as Ya, Paint as Yc, PaintLineCap as Yd, UiInsets as Yf, parseColor as Yg, TextMeasureRequest as Yh, LayoutEngine as Yi, isUiSemanticState as Yl, hasDecorationPhase as Ym, BreakpointArgs as Yn, ScrollbarThumb as Yo, UiInputEvent as Yp, DragOffset as Yr, DEFAULT_FONT_WEIGHT as Ys, createWebGPUSurface as Yt, raiseContrast as Yu, bufferSource as Z, UiDropEffect as Za, ScrollView as Zc, PaintSurface as Zd, noInsets as Zf, rgba as Zg, TextOverflow as Zh, SCROLLBAR_LINGER_MS as Zi, statesEqual as Zl, UI_SUBGRID_AXES as Zm, breakpoint as Zn, scrollRange as Zo, UiKeyboardEvent as Zp, draggable as Zr, ObjectFit as Zs, clearFontStacks as Zt, UiDensity as Zu, buildSemanticsTree as _, UiFrameTime as _a, setSelectionRange as _c, isLayoutProtocol as _d, linearGradient as _f, UiAnimation as _g, UiTextWrapValue as _h, bundle as _i, FlexContainerProps as _l, fade as _m, LayoutInspector as _n, UiScrollBehavior as _o, UiModifierSet as _p, IconSourceArgs as _r, editorFor as _s, INSTANCE_STRIDE_FLOATS as _t, LazyListOptions as _u, diffSemantics as a, RelayoutExplanation as aa, createPaintState as ac, defaultShadows as ad, UiImage as af, createEnvironmentKey as ag, UiFontWeight as ah, borderShapes as ai, UiEventBinding as al, UiWheelDeltaMode as am, PaintContext2D as an, UiShortcutRegistry as ao, UiTextInputState as ap, VideoTransport as ar, setMatchRanges as as, Mp3Frame as at, SheetHeaderRenderer as au, semanticsMemory as b, UiManualFrameClock as ba, RunMeasure as bc, defaultVisualState as bd, AutoLength as bf, UiSpring as bg, validateSubgrid as bh, accumulatedOffsetTo as bi, GridProps as bl, resolveMotionState as bm, Canvas2DRenderer as bn, isScrollContainer as bo, UiModifier as bp, iconSource as br, isMultiline as bs, PrimitiveCommand as bt, VIRTUAL_INDEX_PROP as bu, SemanticsMemory as c, describeOverrides as ca, normalizeVerticalAlign as cc, UiTypographyExtensions as cd, ResolvedGradient as cf, DirtyFlags as cg, UiOverflow as ch, focusRing as ci, UiGraphBuilder as cl, wheelDeltaYOf as cm, PaintTarget as cn, formatShortcut as co, UiGroupEdit as cp, DefaultVideoResolverOptions as cr, findMatchesIn as cs, readMp3Header as ct, SheetSourceArgs as cu, SemanticsRewalk as d, labelNode as da, TEXT_SELECTION_PROP as dc, isTypographyRole as dd, UiGradientOffset as df, UiTransitionValue as dg, UiPosition as dh, hoverable as di, ButtonProps as dl, MOTION_REST as dm, PaintOp as dn, KeyboardControllerOptions as do, comparePositions as dp, VideoResolver as dr, UiEnvironmentKeys as ds, Affine as dt, UiVirtualSheetOptions as du, easings as e_, CustomLayoutExplanation as ea, PaintTextSpan as ec, defaultSpacing as ed, UiPaint as ef, TextRunStyle as eg, UiColorValue as eh, autoFocus as ei, createElement as el, UiPointerDevice as em, PaintCanvas as en, UiFileDropMessage as eo, UiContainerSizeSource as ep, ScrollPositionArgs as er, scrollbarZoneAt as es, Mp4Sample as et, CompositionRange as eu, SemanticsSpan as f, withOverrideSource as fa, TextRange as fc, typographyEqual as fd, UiGradientStop as ff, assertTransitionMap as fg, UiSelfAlignment as fh, interactive as fi, ColumnProps as fl, MotionChannel as fm, PaintRecorder as fn, UiKeyboardController as fo, edgeField as fp, canDecodeVideo as fr, EnvironmentNotifier as fs, CLIP_STRIDE_BYTES as ft, VIRTUAL_SHEET_PROP as fu, buildSemanticsSubtree as g, UiFrameClockFactory as ga, selectionRangeOf as gc, UiLayoutProtocol as gd, gradientsEqual as gf, AnimatedCell as gg, UiTextOverflowValue as gh, UiModifierBundle as gi, EnvironmentProps as gl, ResolvedMotionState as gm, InspectorOverlay as gn, ScrollSink as go, UiModifierLayout as gp, sharedElement as gr, caretVisibleAt as gs, INSTANCE_STRIDE_BYTES as gt, LazyItemRenderer as gu, UiSemanticsRecord as h, UiFrameClock as ha, selectableTextOf as hc, UiLayoutContext as hd, gradientPaint as hf, tween as hg, UiTextDirection as hh, pressable as hi, EditableTextProps as hl, MotionTiming as hm, INSPECTOR_HEAT_MS as hn, ScrollContainerState as ho, UiModifierFocus as hp, motion as hr, EDITOR_PROP as hs, GlyphCommand as ht, LazyGridOptions as hu, UiSemanticsPatch as i, OverrideSources as ia, computeObjectFitRect as ic, UiShadows as id, pathValuesEqual as if, UiEnvironmentKey as ig, UiFlexWrap as ih, FocusRingOptions as ii, UiGraph as il, UiTextChangeEvent as im, paintPictures as in, UiShortcutBinding as io, UiTextInput as ip, VideoState as ir, matchRangesOf as is, Mp3Format as it, LazySheetProps as iu, paragraphGeometry as j, CanvasPlatformSurface as ja, lineStartAt as jc, UiTextLink as jd, isPercentLength as jf, UiInterpolator as jg, UiShapeName as jh, GridContribution as ji, TextContentProps as jl, LayoutStats as jm, OverlayShape as jn, resetOverrideWarnings as jo, UiChild as jp, AnimateLayoutOptions as jr, PlacedTextRun as js, glyphCount as jt, darkTheme as ju, hasDrawnText as k, pointerEventsOf as ka, graphemeBoundaries as kc, UiSpannedText as kd, isFrLength as kf, UiSpringToken as kg, uniformBorderRadius as kh, propertyNarrowers as ki, ScrollViewProps as kl, LayoutBox as km, RenderContext as kn, clearOverrideProperty as ko, ComponentResolver as kp, DefaultImageResolverOptions as kr, EditableLayout as ks, buildRenderList as kt, videoFrameSize as ku, SemanticsPlacement as l, formatConstraints as la, resolvePaintState as lc, UiTypographyRole as ld, ResolvedGradientStop as lf, AnimationDriver as lg, UiPlacement as lh, BUTTON_INTERACTION as li, BoxModelProps as ll, DirtyNodeSet as lm, tracePathData as ln, parseShortcut as lo, UiTextPosition as lp, RangeResponse as lr, UiEnvironmentProvider as ls, splitMp3Frames as lt, SheetViewport as lu, UiSemanticsMap as m, UiAnimationFrameClock as ma, selectableTextNodes as mc, UiLayoutChild as md, UiRadialGradient as mf, spring as mg, UiTextAlign as mh, measureFlow as mi, ContainerProps as ml, MotionStateInput as mm, replayPaint as mn, UiPointerController as mo, UiModifierEnvironment as mp, SharedElementArgs as mr, CARET_WIDTH as ms, CommandKind as mt, LazyAxis as mu, UiSemanticsBox as n, steps as n_, LayoutExplanation as na, VerticalAlign as nc, spacingEqual as nd, inputsEqual as nf, spannedRunsFor as ng, UiCursor as nh, BordersOptions as ni, BindingId as nl, UiPointerKind as nm, PaintPictureCache as nn, ShortcutRegistryOptions as no, containerBands as np, VideoClock as nr, TEXT_MATCHES_PROP as ns, demuxMp4Audio as nt, EditableTextModel as nu, dropIndexShifts as o, SizeDecision as oa, isPaintVisible as oc, shadowsEqual as od, GradientPaint as of, findEnvironmentKey as og, UiGridAutoFlow as oh, borders as oi, ChildrenBindingId as ol, UiWheelEvent as om, PaintGradient as on, UiShortcutStep as oo, textInputOf as op, videoSource as or, FindMatch as os, Mp3Frames as ot, SheetRange as ou, TEXT_RUN_ID_SEPARATOR as p, UiFrame as pa, clearSelectionRange as pc, MAX_MEASURES_PER_CHILD as pd, UiLinearGradient as pf, normalizeTransition as pg, UiSubgridAxis as ph, measure as pi, CommonProps as pl, MotionState as pm, PaintRecording as pn, PointerControllerOptions as po, editingGroupOf as pp, MotionArgs as pr, CARET_BLINK_MS as ps, CLIP_STRIDE_FLOATS as pt, sheetSource as pu, parseWebVtt as q, EXTERNAL_FILES as qa, EditableText as qc, PaintBox as qd, UiInsetRegistry as qf, colorsEqual as qg, TextLine as qh, proportionalFontMetrics as qi, UiSemanticStates as ql, decorationColor as qm, insetPadding as qn, SCROLLBAR_THICKNESS as qo, UiFocusEvent as qp, dropTarget as qr, DEFAULT_FONT_FAMILY as qs, WebGPUCanvasHost as qt, contrastRatio as qu, UiSemanticsUpdate as r, LayoutStateExplanation as ra, colorToCss as rc, spacingSteps as rd, paintValuesEqual as rf, UiEnvironment as rg, UiDirection as rh, Decorations as ri, UiBinding as rl, UiSelectionChangeEvent as rm, PaintStats as rn, UiShortcut as ro, unknownContainerSize as rp, VideoSourceArgs as rr, clearMatchRanges as rs, demuxMp4Video as rt, LazySheet as ru, recordsEqual as s, describeLength as sa, normalizeTextAlign as sc, UiTypography as sd, MAX_GRADIENT_STOPS as sf, UiNodeType as sg, UiObjectFit as sh, decorated as si, UiChildrenBinding as sl, noKeyModifiers as sm, PaintResolver as sn, describeShortcut as so, UiEditingGroup as sp, DefaultVideoResolver as sr, FindOptions as ss, Mp3Header as st, SheetRowRenderer as su, UiSemanticsAction as t, linear as t_, Edges as ta, TextAlign as tc, scaleSpacing as td, UiPath as tf, TextWrap as tg, UiContentDistribution as th, BorderEdge as ti, UiDefinition as tl, UiPointerEvent as tm, PaintCanvasFactory as tn, dragSessionFor as to, bandOf as tp, scrollPosition as tr, SubtreeBounds as ts, Mp4VideoTrack as tt, EditUnit as tu, SemanticsReuse as u, formatExplanation as ua, DEFAULT_LINE_HEIGHT_FACTOR as uc, defaultTypography as ud, UiGradient as uf, UiTransitionSpec as ug, UiPointerEvents as uh, InteractiveOptions as ui, BoxProps as ul, MOTION_CHANNELS as um, EMPTY_RECORDING as un, shortcutKeyCaps as uo, adjacentField as up, VideoPlayback as ur, provideEnvironment as us, WebGPUGlyphPages as ut, UiVirtualSheet as uu, rewalkSemantics as v, UiHostFrameClock as va, CaretRect as vc, UiVisualState as vd, radialGradient as vf, UiAnimationOptions as vg, UiThemeColorName as vh, noModifiers as vi, FlexItemProps as vl, isMotionRest as vm, LayoutInspectorOptions as vn, UiScrollability as vo, UiUnknownModifierPropertyError as vp, ImageSourceArgs as vr, editorOf as vs, ImageCommand as vt, LazySourceArgs as vu, linkHoverOf as w, isNodeHitTestable as wa, lineLimit as wc, UiFontKerning as wd, UiLength as wf, createTween as wg, borderRadiusCorners as wh, getPropertyNames as wi, PaintProps as wl, slideFrom as wm, ScrollLayerStats as wn, PinchRecognizerOptions as wo, UiModifierHost as wp, IconRasterizer as wr, EditCommand as ws, RenderTextCache as wt, VirtualUpdate as wu, textRunOfRecordId as x, UiTimerFrameClock as xa, caretRectFor as xc, hasVisualState as xd, FrLength as xf, UiSpringOptions as xg, UiBorderRadius as xh, contentOffset as xi, IdentityProps as xl, rotateFrom as xm, Canvas2DRendererOptions as xn, GestureInput as xo, UiModifierKind as xp, imageSource as xr, isReadOnly as xs, PrimitiveKind as xt, VIRTUAL_LEAD_PROP as xu, semanticsInertAbove as y, UiHostFrameClockOptions as ya, PlacedLine as yc, UiVisualStateSet as yd, validateGradient as yf, UiReducedMotionPolicy as yg, UiVerticalAlign as yh, Transform as yi, GridItemProps as yl, pop as ym, CanvasTextMeasurer as yn, UiWheelController as yo, assertModifierList as yp, ImageSources as yr, isEditableNode as ys, NO_CLIP_INDEX as yt, UiVirtualWindow as yu, markInstant as z, prepareInputSurface as za, LazyColumn as zc, hiddenRangesOf as zd, boxShadowArraysEqual as zf, transform as zg, lightColors as zh, MainAxisAlignment as zi, UiPropertyValues as zl, UiNode as zm, resolveProperty as zn, HitTestLayoutReader as zo, UiEventListener as zp, PinchableOptions as zr, fillTextRects as zs, initializeWebGPU as zt, defineThemeExtension as zu };
+//# sourceMappingURL=index-DR8HAfh3.d.ts.map