gesso-core 0.7.0 → 0.8.1

package/dist/{index-B5r1ETCh.d.ts → index-BSoAnZP0.d.ts}

@@ -8,6 +8,13 @@ import { BehaviorSubject, Observable, Subject } from "rxjs";
  * easing — so nothing downstream clamps what it returns.
  */
 type UiEasing = (t: number) => number;
+/**
+ * The easing as CSS writes it, `cubic-bezier(0.2, 0, 0, 1)` or `linear`,
+ * for an easing made by `cubicBezier` or `linear`; undefined for one
+ * that is only a function, which CSS cannot name. What a design tool's
+ * handoff writes into a `transition`.
+ */
+declare function easingCss(easing: UiEasing): string | undefined;
 /** Progress equals time. What a spinner and a sweep want. */
 declare const linear: UiEasing;
 /**
@@ -291,11 +298,30 @@ declare function interpolatorFor(from: unknown, to: unknown): UiInterpolator<unk
  * it has forty opinions. the rule for colour —
  * tokens only, never a literal in a component — applies to time.
  */
-type UiDurationToken = 'instant' | 'fast' | 'normal' | 'slow' | 'deliberate';
+type UiDurationToken = 'instant' | 'fast' | 'normal' | 'slow' | 'deliberate' | (keyof UiDurationExtensions & string);
 /** The named curves; see `UiEasing.ts` for what each one is for. */
-type UiEasingToken = keyof typeof easings;
+type UiEasingToken = keyof typeof easings | (keyof UiEasingExtensions & string);
 /** The named springs, for a movement that follows a gesture. */
-type UiSpringToken = 'gentle' | 'snappy' | 'stiff';
+type UiSpringToken = 'gentle' | 'snappy' | 'stiff' | (keyof UiSpringExtensions & string);
+/**
+ * Names an application adds to the vocabulary, as typography roles are
+ * added (`UiTypographyExtensions`): a design's own `press` beside
+ * `fast`, given its value in the motion it provides (`defineMotion`).
+ *
+ *   declare module 'gesso-core' {
+ *     interface UiDurationExtensions {
+ *       readonly press: unknown;
+ *     }
+ *   }
+ *
+ * Only the key is used. Declaring one makes `transition={{ opacity:
+ * 'press' }}` legal and a misspelling a compile error.
+ */
+interface UiDurationExtensions {}
+/** Curves an application names; see `UiDurationExtensions`. */
+interface UiEasingExtensions {}
+/** Springs an application names; see `UiDurationExtensions`. */
+interface UiSpringExtensions {}
 /**
  * A spring, in the physical sense: `stiffness` pulls towards the
  * target, `damping` resists velocity, `mass` resists both.
@@ -314,21 +340,42 @@ interface UiSpringSpec {
 /**
  * A vocabulary of motion, beside the palette and the type scale.
  *
- * It is deliberately **not** a field on `UiTheme`. A theme value is
- * resolved per node — `resolveColorValue` asks what the node inherits
- * — and an animation drives a *cell*, which has no node, so a motion
- * token on the theme would be a token nothing could resolve. That is
- * the mistake `visualState` made: a value
- * shipped where nothing reads it. An application that wants a
- * different feel installs one with `AnimationService.setMotion`, which
- * is per runtime, as everything else in front of the graph is.
+ * It is deliberately **not** a field on `UiTheme`: a theme value is
+ * resolved per node at paint, and a name in an animation is resolved
+ * once, when the animation starts. An application that wants a
+ * different feel installs one with `AnimationService.setMotion`, for
+ * the whole runtime, and a part of the tree may provide another over it
+ * (`UiEnvironmentKeys.motion`): a name in a `transition` or a `motion`
+ * state resolves against the motion where it is drawn (`motionOf`).
  */
 interface UiMotion {
   readonly durations: Readonly<Record<UiDurationToken, number>>;
   readonly easings: Readonly<Record<UiEasingToken, UiEasing>>;
   readonly springs: Readonly<Record<UiSpringToken, UiSpringSpec>>;
 }
+/** What a design changes in the vocabulary: any name, its own included. */
+interface UiMotionChanges {
+  readonly durations?: Readonly<Partial<Record<UiDurationToken, number>>>;
+  readonly easings?: Readonly<Partial<Record<UiEasingToken, UiEasing>>>;
+  readonly springs?: Readonly<Partial<Record<UiSpringToken, UiSpringSpec>>>;
+}
 declare const defaultMotion: UiMotion;
+/**
+ * A vocabulary with a design's own values, Gesso's for the rest:
+ *
+ *   export const motion = defineMotion({ durations: { fast: 100, press: 90 } });
+ *
+ * Provided to a part of the tree (`UiEnvironmentKeys.motion`) or to the
+ * whole runtime (`AnimationService.setMotion`), it is what a name in a
+ * `transition`, a `motion` state or `AnimationService` resolves to.
+ */
+declare function defineMotion(changes: UiMotionChanges): UiMotion;
+/** A duration by name or in milliseconds, as `motion` has it; `normal` for a name it lacks. */
+declare function durationIn(motion: UiMotion, duration: number | UiDurationToken | undefined): number;
+/** A curve by name, or given outright; `standard` for none or a name it lacks. */
+declare function easingIn(motion: UiMotion, easing: UiEasing | UiEasingToken | undefined): UiEasing;
+/** A spring by name, or given outright; `snappy` for none or a name it lacks. */
+declare function springIn(motion: UiMotion, spring: UiSpringSpec | UiSpringToken | undefined): UiSpringSpec;
 //#endregion
 //#region src/animation/UiAnimation.d.ts
 /**
@@ -499,7 +546,8 @@ declare abstract class UiAnimation<T> {
    */
   continueFrom(previous: UiAnimation<T>): void;
   protected onBegin(): void;
-  advance(now: number): void;
+  /** `hold`: at its end, stay there, unfinished, to be sampled again at an earlier time (`UiClock.holding`). */
+  advance(now: number, hold?: boolean): void;
   /**
    * Moves the ideal timeline on by one step.
    *
@@ -597,13 +645,15 @@ declare function createTween<T>(cell: AnimatedCell<T>, to: T, options: UiTweenOp
  */
 type UiTransitionSpec = {
   readonly kind: 'tween';
-  readonly duration: number;
-  readonly easing?: UiEasing;
+  /** Milliseconds, or a name resolved against the motion where it is drawn. */
+  readonly duration: number | UiDurationToken;
+  readonly easing?: UiEasing | UiEasingToken;
   readonly stepMs?: number;
   readonly reducedMotion?: UiReducedMotionPolicy;
 } | {
   readonly kind: 'spring';
-  readonly spring: UiSpringSpec;
+  /** Given outright, or a name resolved against the motion where it is drawn. */
+  readonly spring: UiSpringSpec | UiSpringToken;
   readonly restDelta?: number;
   readonly reducedMotion?: UiReducedMotionPolicy;
 };
@@ -615,10 +665,10 @@ type UiTransitionSpec = {
  * transition does. A spring is for a property that is one number, like
  * `opacity`: a transform only tweens (see `spring`).
  */
-type UiTransitionValue = number | UiTransitionSpec;
+type UiTransitionValue = number | UiDurationToken | UiTransitionSpec;
 /** A tween of `duration` milliseconds along `easing`. */
-declare function tween(duration: number, options?: {
-  easing?: UiEasing;
+declare function tween(duration: number | UiDurationToken, options?: {
+  easing?: UiEasing | UiEasingToken;
   stepMs?: number;
   reducedMotion?: UiReducedMotionPolicy;
 }): UiTransitionSpec;
@@ -639,143 +689,6 @@ declare function normalizeTransition(value: UiTransitionValue): UiTransitionSpec
  */
 declare function assertTransitionMap(nodeId: string, value: unknown, isKnownProperty: (name: string) => boolean): ReadonlyMap<string, UiTransitionSpec>;
 //#endregion
-//#region src/animation/AnimationDriver.d.ts
-/**
- * The running animations of one runtime, and the thing the `ticks`
- * phase advances.
- *
- * **One animation per cell.** Starting a second one on a cell
- * supersedes the first, which completes without reaching its target.
- * That rule is not a simplification: it is what makes a gesture work
- * — every retarget while a finger moves is a new animation on the same
- * cell — and it removes the whole question of what two animations
- * writing one value would mean.
- *
- * The driver is per runtime for the reason `MediaService` is: the
- * playground runs several runtimes in one worker, and a module-level
- * set of animations would tick a disposed runtime's cells.
- */
-declare class AnimationDriver {
-  private readonly running;
-  private reducedMotion;
-  private hidden;
-  private wake;
-  /**
-   * Called when an animation enters the running set on an idle driver.
-   *
-   * The runtime arms a frame here. Without it an animation started
-   * from a click handler that changes nothing else would never get a
-   * first frame: the scheduler arms only on dirt, the animation's dirt
-   * is made inside a frame, and no frame would ever come. Re-arming
-   * *between* frames is `scheduleAnimationTick`'s job; this is only
-   * the first one.
-   */
-  setWakeListener(listener: (() => void) | null): void;
-  /** Whether anything is running, so the `ticks` phase can report 0. */
-  get isRunning(): boolean;
-  get size(): number;
-  /** Whether a person has asked for less motion; see `UiReducedMotionPolicy`. */
-  get isReducedMotion(): boolean;
-  /**
-   * Whether an animation should be put where it is going instead of
-   * being run there.
-   *
-   * Two questions with one answer: a person who has asked for less
-   * motion and a page nobody is looking at both want the end state and
-   * not the journey to it, and in both cases `keep` is the way an
-   * animation says its movement is the information rather than the
-   * decoration.
-   */
-  private lands;
-  /**
-   * Starts an animation, replacing whatever was driving its cell.
-   *
-   * Returns the values it will write. Under reduced motion, or while
-   * the document is hidden, an animation whose policy is `snap` never
-   * enters the set at all: the cell takes its target here, in the
-   * caller's turn, and the returned observable has already completed.
-   * So a reduced-motion app runs no animation frames, rather than
-   * running them and drawing the same thing sixty times.
-   */
-  start<T>(animation: UiAnimation<T>): Observable<T>;
-  /** The animation currently driving a cell, if any. */
-  animationFor<T>(cell: AnimatedCell<T>): UiAnimation<T> | undefined;
-  /**
-   * Stops whatever is driving a cell, leaving it where it stands.
-   *
-   * This is how a node leaving the tree releases its animations, which
-   * is the leak the media tier names for image bitmaps and which
-   * matters here too: a driver holding a cell holds every closure the
-   * component that made it captured.
-   */
-  stop<T>(cell: AnimatedCell<T>): boolean;
-  stopAll(): void;
-  /**
-   * A person's motion preference changed.
-   *
-   * Turning it on finishes everything already in flight that is
-   * willing to be finished, rather than leaving a dialog stuck
-   * half-faded until the animation it was told not to run runs out.
-   */
-  setReducedMotion(reduced: boolean): void;
-  /**
-   * The document went out of sight, or came back.
-   *
-   * A hidden page still paints. The runtime deliberately keeps giving
-   * frames to a change that genuinely happened, so the canvas holds a
-   * correct picture rather than whatever was on it when the tab went
-   * away, and a route loaded hidden is drawn once its images have
-   * decoded rather than being left half empty. What it does not do is
-   * advance animations, because frames spent watching something move
-   * that nobody can see are frames spent for nothing.
-   *
-   * Those two together leave an animation frozen at whatever value it
-   * had reached, and painted there. For most animations that is
-   * harmless: a colour halfway between two colours is still a colour.
-   * For an **entrance** it is not, because an entrance begins at
-   * `opacity: 0` and its frozen first value is an element that is not
-   * there. Segue's track page, opened in a background tab, held sixty
-   * two pixels of empty page where its play button belonged, and every
-   * screen built from `motion({ initial })` did the same. It came back
-   * the moment the tab did, which is exactly why it reads as a
-   * rendering bug rather than as a tab that is not being drawn.
-   *
-   * So a hidden page lands its animations instead of freezing them, in
-   * the same way and for the same reason a reduced-motion preference
-   * does: what an animation has to say to nobody is nothing, and the
-   * state it was going to end at is the one the page should be holding
-   * while it waits to be looked at. An animation whose movement is the
-   * information (`keep`) is left alone either way, so a spinner is
-   * still a spinner when the tab comes back.
-   */
-  setHidden(hidden: boolean): void;
-  /** Puts everything that may be landed where it was going. */
-  private landRunning;
-  /**
-   * When the earliest animation next wants a frame, or undefined when
-   * nothing is running.
-   *
-   * This is the whole answer to "how does an animation keep frames
-   * coming on an idle app". The runtime asks after every frame: an
-   * answer at or before `now` means arm the next frame, a later one
-   * means a timer, and undefined means arm nothing — which is why an
-   * idle app's profile reads `ticks 0.00` for the strong reason (no
-   * frames at all) rather than the weak one (frames that did nothing).
-   */
-  nextTickAt(now: number): number | undefined;
-  /**
-   * Advances every animation whose next sample is due, writing each
-   * one's cell. This is the `ticks` phase.
-   *
-   * It runs before the dirty set is snapshotted for exactly the reason
-   * `patches` and `environment` do: the writes it makes have to belong
-   * to the frame about to be collected, or a frame would draw the
-   * previous tick's values and every animation would run one frame
-   * behind.
-   */
-  advance(now: number): void;
-}
-//#endregion
 //#region src/graph/DirtyFlags.d.ts
 declare enum DirtyFlags {
   None = 0,
@@ -841,6 +754,27 @@ declare function createEnvironmentKey<T>(options: {
  * declared as a key.
  */
 declare function findEnvironmentKey(name: string): UiEnvironmentKey<unknown> | undefined;
+/**
+ * A value a node provides for a key of your own, to everything under
+ * it: `provide={[provided(Session, session)]}`.
+ *
+ * The keys Gesso declares are provided by props of their own (`theme`,
+ * `pointer`, `contentColor`); this is how a key made with
+ * `createEnvironmentKey` is. A component under the node reads it with
+ * `ctx.environment(key)`. What the environment holds is compared by
+ * the key's `compare`, else by identity, so a value that changes often
+ * is better provided as a source (a cell) than as each new value: the
+ * source is set once and never compares unequal again.
+ */
+interface UiProvision<T = unknown> {
+  readonly key: UiEnvironmentKey<T>;
+  readonly value: T;
+}
+/**
+ * A value for `key`, for a node's `provide`. Typed against the key
+ * here and erased in the result, so one list holds keys of any type.
+ */
+declare function provided<T>(key: UiEnvironmentKey<T>, value: T): UiProvision;
 //#endregion
 //#region src/environment/UiEnvironment.d.ts
 /**
@@ -909,6 +843,86 @@ declare class UiEnvironment {
   providesOwn(name: string): boolean;
 }
 //#endregion
+//#region src/layout/LayoutTypes.d.ts
+interface Size {
+  width: number;
+  height: number;
+}
+interface LayoutBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * Options applied to a Constraints instance.
+ *
+ * An explicit width/height makes that axis tight
+ * (min === max), mirroring CSS replaced sizing.
+ */
+interface TightenOptions {
+  width?: number;
+  height?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  minHeight?: number;
+  maxHeight?: number;
+}
+/**
+ * Immutable bounds handed down the layout tree.
+ *
+ * Unbounded axes use Infinity for max.
+ */
+declare class Constraints {
+  readonly minWidth: number;
+  readonly maxWidth: number;
+  readonly minHeight: number;
+  readonly maxHeight: number;
+  constructor(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number);
+  static unbounded(): Constraints;
+  static tight(width: number, height: number): Constraints;
+  static loose(width: number, height: number): Constraints;
+  hasBoundedWidth(): boolean;
+  hasBoundedHeight(): boolean;
+}
+/** What one layout call did; see LayoutEngine.stats. */
+interface LayoutStats {
+  /** Nodes whose measure ran (memo hits excluded). */
+  measured: number;
+  /** Nodes whose place ran. */
+  placed: number;
+  /** Laid-out subtrees that moved without changing size, and were shifted rather than placed again. */
+  shifted: number;
+  /** Subtrees laid out from a relayout boundary instead of the root. */
+  relayoutRoots: number;
+  /** Whether the pass started from the root. */
+  fullLayout: boolean;
+  /** Every node whose measure ran, in order, when `LayoutEngine.trace` is on. */
+  measuredNodes: UiNode[];
+}
+/**
+ * The result of a full layout pass for the layout root.
+ *
+ * Descendant geometry is read from LayoutRecords.
+ */
+interface LayoutResult {
+  root: UiNode;
+  box: LayoutBox;
+  contentWidth: number;
+  contentHeight: number;
+  scrollX: number;
+  scrollY: number;
+  clip: LayoutBox;
+}
+declare function clampSize(constraints: Constraints, width: number, height: number): Size;
+declare function constraintsEqual(a: Constraints, b: Constraints): boolean;
+/**
+ * Returns new constraints with the options applied on top of
+ * the supplied constraints. Explicit sizes make an axis tight,
+ * min/max values tighten the existing bounds.
+ */
+declare function tightenConstraints(constraints: Constraints, options: TightenOptions): Constraints;
+//#endregion
 //#region src/layout/TextMeasurer.d.ts
 type TextWrap = 'word' | 'char' | 'none';
 type TextOverflow = 'clip' | 'ellipsis';
@@ -1880,8 +1894,11 @@ declare const UI_SUBGRID_AXES: readonly UiSubgridAxis[];
 declare function validateSubgrid(value: unknown): string | undefined;
 type UiPosition = 'static' | 'relative' | 'absolute' | 'sticky';
 type UiOverflow = 'visible' | 'hidden' | 'scroll' | 'auto';
-/** Side and alignment of an anchored node against its anchor. */
-type UiPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+/**
+ * Side and alignment of an anchored node against its anchor, or `over`
+ * it: laid over the anchor's box, grown by the offset on every side.
+ */
+type UiPlacement = 'over' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
 type UiTextWrapValue = 'word' | 'char' | 'none';
 type UiTextOverflowValue = 'clip' | 'ellipsis';
 /**
@@ -2062,6 +2079,12 @@ interface UiPropertyOverride {
   readonly name: string;
   order: number;
   value: unknown;
+  /**
+   * Drawn at once, past any transition the node declares, and taken
+   * away at once too: a design tool's preview of a value being chosen,
+   * which has to keep up with the drag that chooses it.
+   */
+  readonly snap?: boolean;
 }
 /**
  * The cascade for one overridden property: the element's own value,
@@ -2087,9 +2110,23 @@ interface UiPropertyOverrides {
 interface UiNodeTransitions {
   /** Takes over a write by animating towards it, or declines it. */
   write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
+  /** Stops animating one property, leaving it where it stands, for a write that is drawn at once. */
+  cancel(property: NodeProperty): void;
+  /** What the element declares, by property, as written: a name stays a name. For a tool that reads it. */
+  readonly declared: ReadonlyMap<NodeProperty, UiTransitionSpec>;
   /** Cancels everything, for a node leaving the tree. */
   release(): void;
 }
+/**
+ * What a held subtree is waiting to do: the marks its descendants were
+ * given while it was held, and the environment its descendants are to
+ * take again when it is let go. See `UiGraph.hold`.
+ */
+interface UiHold {
+  readonly pending: Map<UiNode, DirtyFlags>;
+  /** The inherited-property flags a rebuild of the subtree's environment is owed, or None. */
+  environment: DirtyFlags;
+}
 declare class UiNode {
   readonly id: NodeId;
   readonly type: UiNodeType;
@@ -2153,111 +2190,260 @@ declare class UiNode {
    */
   environment: UiEnvironment | null;
   /**
-   * Shapes the node's modifiers put in its own paint pass, merged in
-   * modifier order.
+   * Shapes the node's modifiers put in its own paint pass, merged in
+   * modifier order.
+   *
+   * Null until a modifier decorates, so the cost to an undecorated
+   * node is the one null check each renderer already makes per node,
+   * and a tree of ten thousand plain boxes pays nothing. Written only
+   * through `UiModifierHost.decorate`; see `rendering/Decorations.ts`
+   * for what a shape means and where it lands.
+   */
+  decorations: readonly DecorationShape[] | null;
+  /**
+   * How this node's properties get from one value to the next.
+   *
+   * Null until the element declares a `transition`, so the cost to a
+   * tree without one is a field read on the property write path — the
+   * same shape, and the same argument, as `overrides` above.
+   */
+  transitions: UiNodeTransitions | null;
+  /**
+   * Set on a node whose subtree is held (see `UiGraph.hold`): what its
+   * descendants were marked dirty with while it was, to be marked again
+   * when it is let go. Null on every node that holds nothing.
+   */
+  hold: UiHold | null;
+  /**
+   * The held node this one is inside, or null. Kept on every descendant
+   * of a held node, so a mark finds out it is to wait with one field
+   * read rather than a walk up the tree.
+   */
+  heldBy: UiNode | null;
+  hasChildren(): boolean;
+  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/animation/UiClock.d.ts
+/**
+ * How time passes for the animations under a node: at a speed of its
+ * own, or not at all.
+ *
+ * A node provides one to its subtree,
+ * `provide={[provided(UiEnvironmentKeys.clock, clock)]}`, and every
+ * animation started there runs on it: a transition, a `motion` state,
+ * hover and press, and `AnimationService.animate` given the node it
+ * animates `on`. Nothing provided is real time.
+ *
+ * What a design tool needs to show one screen two ways at once. The
+ * frames on its board are pictures: under a `settled` clock every
+ * animation lands where it is going the moment it starts, and a loop
+ * holds still. The screen it plays runs at the person's own speed, a
+ * quarter of it to watch a press closely, or paused. Reduced motion and
+ * a hidden page are the whole app's; this is one part of it.
+ *
+ * An animation takes all its time from the driver, which hands each
+ * the local time of its clock, so nothing inside a tween or a spring
+ * knows; and the driver asks for the next frame in real time, so a
+ * slowed clock asks for frames as often as it needs them and a paused
+ * one asks for none.
+ */
+declare class UiClock {
+  private rate;
+  /** A real time and the local time it was, from the last change of speed: where local time is measured from. */
+  private anchor;
+  /** The real time last asked about, where a change of speed takes effect. */
+  private lastReal;
+  /** Every animation lands where it is going, and none runs. */
+  settled: boolean;
+  /**
+   * Animations that reach their end stay, held there, rather than
+   * finishing: so moving the time back (`seek`) plays them back. What a
+   * design tool scrubs a transition with; let go, they finish as they
+   * would have. A spring, which is worked out step by step rather than
+   * from the time, holds but does not run back.
+   */
+  holding: boolean;
+  /** Bumped by `seek`, so a driver knows to draw again at the new time. */
+  moves: number;
+  constructor(options?: {
+    readonly speed?: number;
+    readonly settled?: boolean;
+  });
+  /** How fast time passes: 1 is real time, 0.25 a quarter of it, 0 paused. */
+  get speed(): number;
+  set speed(next: number);
+  /** The local time now, as last asked: where a seek is measured from. */
+  get now(): number;
+  /**
+   * Puts local time at `at`, from now on: forward, or back to replay
+   * what is held (`holding`). Paused, it stays there; running, it goes
+   * on from there.
+   */
+  seek(at: number): void;
+  /** The local time at real time `now`. The first time asked, the two agree. */
+  local(now: number): number;
+  /** The real time at which local time `at` comes; Infinity while paused. */
+  real(at: number): number;
+}
+/** The motion vocabulary names resolve to under `node`: the nearest provided above it, or Gesso's. */
+declare function motionOf(node: UiNode | null | undefined): UiMotion;
+/** The clock the animations under `node` run on: the nearest one provided above it, or null for real time. */
+declare function clockOf(node: UiNode | null | undefined): UiClock | null;
+//#endregion
+//#region src/animation/AnimationDriver.d.ts
+/**
+ * The running animations of one runtime, and the thing the `ticks`
+ * phase advances.
+ *
+ * **One animation per cell.** Starting a second one on a cell
+ * supersedes the first, which completes without reaching its target.
+ * That rule is not a simplification: it is what makes a gesture work
+ * — every retarget while a finger moves is a new animation on the same
+ * cell — and it removes the whole question of what two animations
+ * writing one value would mean.
+ *
+ * The driver is per runtime for the reason `MediaService` is: the
+ * playground runs several runtimes in one worker, and a module-level
+ * set of animations would tick a disposed runtime's cells.
+ */
+declare class AnimationDriver {
+  private readonly running;
+  /** The clock each running animation was started on, when it was not real time; see `UiClock`. */
+  private readonly clocks;
+  /** Each clock's `moves` as last drawn: one moved since (a seek) is drawn at its new time at once. */
+  private readonly seenMoves;
+  private reducedMotion;
+  private hidden;
+  private advancing;
+  private wake;
+  /**
+   * Called when an animation enters the running set on an idle driver.
+   *
+   * The runtime arms a frame here. Without it an animation started
+   * from a click handler that changes nothing else would never get a
+   * first frame: the scheduler arms only on dirt, the animation's dirt
+   * is made inside a frame, and no frame would ever come. Re-arming
+   * *between* frames is `scheduleAnimationTick`'s job; this is only
+   * the first one.
+   */
+  setWakeListener(listener: (() => void) | null): void;
+  /**
+   * Whether a frame of the running animations is being written now: a
+   * value written meanwhile is a step of an animation, not a change for
+   * a transition to animate again.
+   */
+  get isAdvancing(): boolean;
+  /** Whether anything is running, so the `ticks` phase can report 0. */
+  get isRunning(): boolean;
+  get size(): number;
+  /** Whether a person has asked for less motion; see `UiReducedMotionPolicy`. */
+  get isReducedMotion(): boolean;
+  /**
+   * Whether an animation should be put where it is going instead of
+   * being run there.
+   *
+   * Two questions with one answer: a person who has asked for less
+   * motion and a page nobody is looking at both want the end state and
+   * not the journey to it, and in both cases `keep` is the way an
+   * animation says its movement is the information rather than the
+   * decoration.
+   */
+  private lands;
+  /**
+   * Starts an animation, replacing whatever was driving its cell.
+   *
+   * Returns the values it will write. Under reduced motion, or while
+   * the document is hidden, an animation whose policy is `snap` never
+   * enters the set at all: the cell takes its target here, in the
+   * caller's turn, and the returned observable has already completed.
+   * So a reduced-motion app runs no animation frames, rather than
+   * running them and drawing the same thing sixty times.
+   */
+  start<T>(animation: UiAnimation<T>, clock?: UiClock | null): Observable<T>;
+  /** The animation currently driving a cell, if any. */
+  animationFor<T>(cell: AnimatedCell<T>): UiAnimation<T> | undefined;
+  /**
+   * Stops whatever is driving a cell, leaving it where it stands.
+   *
+   * This is how a node leaving the tree releases its animations, which
+   * is the leak the media tier names for image bitmaps and which
+   * matters here too: a driver holding a cell holds every closure the
+   * component that made it captured.
+   */
+  stop<T>(cell: AnimatedCell<T>): boolean;
+  stopAll(): void;
+  /**
+   * A person's motion preference changed.
+   *
+   * Turning it on finishes everything already in flight that is
+   * willing to be finished, rather than leaving a dialog stuck
+   * half-faded until the animation it was told not to run runs out.
+   */
+  setReducedMotion(reduced: boolean): void;
+  /**
+   * The document went out of sight, or came back.
+   *
+   * A hidden page still paints. The runtime deliberately keeps giving
+   * frames to a change that genuinely happened, so the canvas holds a
+   * correct picture rather than whatever was on it when the tab went
+   * away, and a route loaded hidden is drawn once its images have
+   * decoded rather than being left half empty. What it does not do is
+   * advance animations, because frames spent watching something move
+   * that nobody can see are frames spent for nothing.
+   *
+   * Those two together leave an animation frozen at whatever value it
+   * had reached, and painted there. For most animations that is
+   * harmless: a colour halfway between two colours is still a colour.
+   * For an **entrance** it is not, because an entrance begins at
+   * `opacity: 0` and its frozen first value is an element that is not
+   * there. Segue's track page, opened in a background tab, held sixty
+   * two pixels of empty page where its play button belonged, and every
+   * screen built from `motion({ initial })` did the same. It came back
+   * the moment the tab did, which is exactly why it reads as a
+   * rendering bug rather than as a tab that is not being drawn.
+   *
+   * So a hidden page lands its animations instead of freezing them, in
+   * the same way and for the same reason a reduced-motion preference
+   * does: what an animation has to say to nobody is nothing, and the
+   * state it was going to end at is the one the page should be holding
+   * while it waits to be looked at. An animation whose movement is the
+   * information (`keep`) is left alone either way, so a spinner is
+   * still a spinner when the tab comes back.
+   */
+  setHidden(hidden: boolean): void;
+  /** Puts everything that may be landed where it was going. */
+  private landRunning;
+  /**
+   * When the earliest animation next wants a frame, or undefined when
+   * nothing is running.
    *
-   * Null until a modifier decorates, so the cost to an undecorated
-   * node is the one null check each renderer already makes per node,
-   * and a tree of ten thousand plain boxes pays nothing. Written only
-   * through `UiModifierHost.decorate`; see `rendering/Decorations.ts`
-   * for what a shape means and where it lands.
+   * This is the whole answer to "how does an animation keep frames
+   * coming on an idle app". The runtime asks after every frame: an
+   * answer at or before `now` means arm the next frame, a later one
+   * means a timer, and undefined means arm nothing — which is why an
+   * idle app's profile reads `ticks 0.00` for the strong reason (no
+   * frames at all) rather than the weak one (frames that did nothing).
    */
-  decorations: readonly DecorationShape[] | null;
+  nextTickAt(now: number): number | undefined;
   /**
-   * How this node's properties get from one value to the next.
+   * Advances every animation whose next sample is due, writing each
+   * one's cell. This is the `ticks` phase.
    *
-   * Null until the element declares a `transition`, so the cost to a
-   * tree without one is a field read on the property write path — the
-   * same shape, and the same argument, as `overrides` above.
+   * It runs before the dirty set is snapshotted for exactly the reason
+   * `patches` and `environment` do: the writes it makes have to belong
+   * to the frame about to be collected, or a frame would draw the
+   * previous tick's values and every animation would run one frame
+   * behind.
    */
-  transitions: UiNodeTransitions | null;
-  hasChildren(): boolean;
-  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
-interface Size {
-  width: number;
-  height: number;
-}
-interface LayoutBox {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-/**
- * Options applied to a Constraints instance.
- *
- * An explicit width/height makes that axis tight
- * (min === max), mirroring CSS replaced sizing.
- */
-interface TightenOptions {
-  width?: number;
-  height?: number;
-  minWidth?: number;
-  maxWidth?: number;
-  minHeight?: number;
-  maxHeight?: number;
-}
-/**
- * Immutable bounds handed down the layout tree.
- *
- * Unbounded axes use Infinity for max.
- */
-declare class Constraints {
-  readonly minWidth: number;
-  readonly maxWidth: number;
-  readonly minHeight: number;
-  readonly maxHeight: number;
-  constructor(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number);
-  static unbounded(): Constraints;
-  static tight(width: number, height: number): Constraints;
-  static loose(width: number, height: number): Constraints;
-  hasBoundedWidth(): boolean;
-  hasBoundedHeight(): boolean;
-}
-/** What one layout call did; see LayoutEngine.stats. */
-interface LayoutStats {
-  /** Nodes whose measure ran (memo hits excluded). */
-  measured: number;
-  /** Nodes whose place ran. */
-  placed: number;
-  /** Laid-out subtrees that moved without changing size, and were shifted rather than placed again. */
-  shifted: number;
-  /** Subtrees laid out from a relayout boundary instead of the root. */
-  relayoutRoots: number;
-  /** Whether the pass started from the root. */
-  fullLayout: boolean;
-  /** Every node whose measure ran, in order, when `LayoutEngine.trace` is on. */
-  measuredNodes: UiNode[];
-}
-/**
- * The result of a full layout pass for the layout root.
- *
- * Descendant geometry is read from LayoutRecords.
- */
-interface LayoutResult {
-  root: UiNode;
-  box: LayoutBox;
-  contentWidth: number;
-  contentHeight: number;
-  scrollX: number;
-  scrollY: number;
-  clip: LayoutBox;
+  advance(now: number): void;
+  private advanceRunning;
+  private advanceEach;
 }
-declare function clampSize(constraints: Constraints, width: number, height: number): Size;
-declare function constraintsEqual(a: Constraints, b: Constraints): boolean;
-/**
- * Returns new constraints with the options applied on top of
- * the supplied constraints. Explicit sizes make an axis tight,
- * min/max values tighten the existing bounds.
- */
-declare function tightenConstraints(constraints: Constraints, options: TightenOptions): Constraints;
 //#endregion
 //#region src/animation/UiSharedElements.d.ts
 /**
@@ -3238,8 +3424,11 @@ interface ComponentResolver {
    * Called on every reconcile pass that reaches the slot. Returning
    * the same value for an unchanged component is expected; the
    * builder reconciles it idempotently.
+   *
+   * `anchor` is the slot's node, already under its parent, so what
+   * the component is placed in can be read while its body runs.
    */
-  resolve(element: ComponentLikeElement, anchorId: string): UiChild;
+  resolve(element: ComponentLikeElement, anchorId: string, anchor?: UiNode): UiChild;
   /**
    * Tears down the host owning `anchorId`.
    *
@@ -3333,6 +3522,12 @@ type FocusModality = 'pointer' | 'keyboard';
  * dialog modal for the keyboard. `popScope()` restores focus to
  * whatever held it when the scope was pushed. Components reach both
  * through `FocusService`, never directly.
+ *
+ * A scope inside a bound (`setFocusBounds`) is modal only inside it. A
+ * dialog open in one of a design tool's frames confines the keyboard in
+ * that frame, when it is there, and leaves the tool around it, and every
+ * other frame, to the person: it takes no focus from outside, and gives
+ * none back when it closes.
  */
 declare class UiFocusManager {
   private readonly dispatcher;
@@ -3349,11 +3544,17 @@ declare class UiFocusManager {
   private readonly listeners;
   private readonly scopeListeners;
   private readonly scopes;
+  private isBound;
   /** The field of each editing group that last had focus, where Tab back into the group lands. */
   private readonly groupEntries;
   constructor(root: UiNode, dispatcher: UiInputDispatcher);
   /** The root used for focus-order traversal. Clears any active scope. */
   setRoot(root: UiNode): void;
+  /**
+   * Which nodes bound a scope taken inside them: a trap under one is
+   * modal only inside it. `OverlayScope`'s, set by the framework.
+   */
+  setFocusBounds(isBound: ((node: UiNode) => boolean) | null): void;
   /** The node that currently holds logical focus, or null. */
   get focusedNode(): UiNode | null;
   hasFocus(): boolean;
@@ -3421,7 +3622,8 @@ declare class UiFocusManager {
   /** Moves focus to the previous focusable node, wrapping to the last. */
   focusPrevious(): boolean;
   /**
-   * Confines focus to `root` until the matching `popScope`.
+   * Confines focus to `root` until the matching `popScope`; inside a
+   * bound, only for focus inside it (see the class's note).
    *
    * Focus that is outside the new scope moves to its first focusable,
    * so the very next Tab stays inside; a scope with nothing focusable
@@ -3491,6 +3693,12 @@ declare class UiFocusManager {
    * stops, which is what lets a dialog body be the keyboard's home of
    * last resort without becoming a stop of its own.
    */
+  /**
+   * The tab stops under `within`, or in the active scope, in the order
+   * Tab visits them: what a design tool numbers to show a screen's
+   * keyboard order.
+   */
+  tabStops(within?: UiNode): UiNode[];
   private collectFocusable;
   /** Whether an ancestor is hidden or disabled, which takes the node's focus away with it. */
   private insideHidden;
@@ -3498,6 +3706,18 @@ declare class UiFocusManager {
   private groupOf;
   /** Whether the node may hold focus given the active scope, if any. */
   private withinScope;
+  /**
+   * The innermost scope that confines a node: a bounded one only inside
+   * its bound, so a node, or no focus at all, outside it answers to the
+   * scope under it.
+   */
+  private scopeFor;
+  /**
+   * The bound above a scope's root, found once the root is in the tree
+   * (a trap is taken from a `ref`, which may fire before) and kept, so
+   * a scope whose subtree has gone still knows it.
+   */
+  private boundOf;
   /** Whether the node is still connected to the traversal root. */
   private isAttached;
   private isWithin;
@@ -3644,6 +3864,19 @@ interface UiModifierHost {
    * one is painted unsettled and warned about rather than hanging.
    */
   onLayout(listener: (box: LayoutBox) => void): void;
+  /**
+   * Called after any frame that changed the node's `flowBox` or its own
+   * scroll offset, with the `flowBox`; not when a scroll or a transform
+   * above it only moves it on screen. Removed on detach.
+   *
+   * The one to use when what the listener reads is the node's own place
+   * in the layout — its size for a breakpoint, its box for a layout
+   * animation, its offset for a scroll position — which a pan of a
+   * design tool's board, or a page's scroll, does not change. Asking
+   * nothing on those frames is most of what it is for. Runs where
+   * `onLayout` runs, with the same freedom to change layout.
+   */
+  onFlowLayout(listener: (box: LayoutBox) => void): void;
   /**
    * The value the node inherits for an environment key: what the
    * nearest provider above it supplies, else the key's default.
@@ -3819,6 +4052,8 @@ interface UiModifierLayout {
    */
   viewport?(): LayoutBox | null;
   onLayout(node: UiNode, listener: (box: LayoutBox) => void): () => void;
+  /** See `UiModifierHost.onFlowLayout`. Absent, `onLayout` stands in, which tells a listener more often, never less. */
+  onFlowLayout?(node: UiNode, listener: (box: LayoutBox) => void): () => void;
 }
 /**
  * Where a modifier's focus access comes from.
@@ -3870,6 +4105,8 @@ declare class UiModifierSet {
   private decorationsFor;
   /** The names of what is attached, in order, for the inspector. */
   get names(): string[];
+  /** What is attached, each kind with its current arguments, in order: for a tool reading what a node does. */
+  get modifiers(): readonly UiModifier[];
   get size(): number;
   /**
    * Brings the attached set in line with what the element declares.
@@ -4628,6 +4865,14 @@ declare const BOX_SHADOW_BLUR_REACH = 1.5;
  * one's hole shrinks with it. A square corner stays square, as CSS
  * keeps it.
  */
+/**
+ * A box's corner radius as its shadows take it: no more than half its
+ * shorter side, as CSS shrinks radii to fit the box before a shadow is
+ * spread from them. A box of no size with a 16 radius has no corners,
+ * so the hole an outer shadow leaves under it is nothing: a spotlight's
+ * hole shrunk to a point showed a 16-pixel circle where there was none.
+ */
+declare function fittedShadowRadius(boxRadius: number, width: number, height: number): number;
 declare function boxShadowRadius(boxRadius: number, spreadRadius: number, inset: boolean): number;
 /**
  * How far past each side of the box a node's outer shadows may paint,
@@ -5195,6 +5440,16 @@ interface UiGradientStop {
    * does.
    */
   readonly color: UiColorValue;
+  /**
+   * How much of the colour shows, 0 to 1, multiplied into its alpha once
+   * a palette name has been resolved: `{ color: 'background', opacity: 0 }`.
+   *
+   * What a fade to nothing is made of. A canvas blends a gradient's stops
+   * without premultiplying, so a ramp from white to `transparent`, which
+   * is transparent *black*, passes through grey on its way out; a ramp to
+   * the same colour at no opacity stays that colour all the way.
+   */
+  readonly opacity?: number;
 }
 interface UiLinearGradient {
   readonly kind: 'linear';
@@ -5422,12 +5677,44 @@ interface PaintSurface {
   /** Multiplies into the opacity already in force, as a node's does. */
   alpha(value: number): void;
   /**
-   * Blurs everything drawn after it, by a radius in logical pixels.
+   * Blurs everything drawn after it, by a radius (CSS's standard
+   * deviation) in the current coordinates, so a blur under a `scale`
+   * scales with what it blurs. The transform in force at the call is
+   * the one it is measured in.
    *
    * Scoped by `save` and `restore` like every other style value, so a
    * frosted panel is `save`, `blur`, draw, `restore`. Zero clears it.
    */
   blur(radius: number): void;
+  /**
+   * Starts a masked layer: what is drawn from here to `layerMask` is
+   * the layer's content, kept apart from what is drawn already and cut
+   * to this rectangle, in the current coordinates.
+   *
+   * Saves the state as `save` does. The content starts with the
+   * transform in force and an empty path, and with every other style
+   * value at its initial one: the alpha, blur and clip in force here
+   * apply to the layer as a whole, when `endMaskedLayer` draws it.
+   *
+   * An SVG `<mask>` and a drop shadow are both drawn this way. A host
+   * that cannot keep a layer apart draws the content unmasked and the
+   * mask not at all, which is a picture that is wrong in one detail
+   * rather than missing.
+   */
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  /**
+   * Ends the layer's content and starts its mask: the state is as
+   * `beginMaskedLayer` found it, the path empty, and the mask cut to the
+   * same rectangle. Where the mask is drawn the content shows, by how
+   * much `mode` says; where nothing is, nothing does.
+   */
+  layerMask(mode?: PaintMaskMode): void;
+  /**
+   * Draws the layer's content, masked, where it began, and restores the
+   * state `beginMaskedLayer` saved. A layer ended without a mask draws
+   * its content as it is.
+   */
+  endMaskedLayer(): void;
   /** Fills the current path. The default rule is `nonzero`. */
   fill(rule?: PaintFillRule): void;
   stroke(): void;
@@ -5449,6 +5736,13 @@ type PaintFillRule = 'nonzero' | 'evenodd';
 type PaintLineCap = 'butt' | 'round' | 'square';
 type PaintLineJoin = 'miter' | 'round' | 'bevel';
 type PaintTextAlign = 'left' | 'center' | 'right';
+/**
+ * How a layer's mask says how much of it shows. `luminance`, the
+ * default, is SVG's `<mask>` and CSS's `mask-type: luminance`: the
+ * mask's brightness times its alpha, so white shows the content and
+ * black hides it. `alpha` is the mask's alpha alone, whatever its colour.
+ */
+type PaintMaskMode = 'luminance' | 'alpha';
 /** The little of a text style a single painted line can carry. */
 interface PaintTextStyle {
   readonly fontSize?: number;
@@ -6902,6 +7196,16 @@ declare function validateRole(value: unknown): string | undefined;
 declare function validateStates(value: unknown): string | undefined;
 //#endregion
 //#region src/properties/UiProperty.d.ts
+/**
+ * When a subtree is held (`holdUnseen`): out of view, or, with
+ * `belowScale`, also when drawn smaller than that share of its size.
+ * `margin` is how far outside the view, in screen pixels, still counts
+ * as in it, so a pan reaches it already caught up; 0 by default.
+ */
+type UiHoldUnseen = true | {
+  readonly belowScale?: number;
+  readonly margin?: number;
+};
 declare const UiProperties: {
   readonly width: UiPropertyDefinition<UiLength | undefined>;
   readonly height: UiPropertyDefinition<UiLength | undefined>;
@@ -7151,7 +7455,10 @@ declare const UiProperties: {
    * Side and alignment against the anchor: 'bottom' (default),
    * 'bottom-start', 'bottom-end', 'top', 'top-start', 'top-end',
    * 'left', 'left-start', 'left-end', 'right', 'right-start',
-   * 'right-end'.
+   * 'right-end'; or 'over', which lays the node over the anchor at its
+   * size, grown by `anchorOffset` on every side: a spotlight's hole, a
+   * focus ring drawn above everything, following the anchor as any
+   * anchored node does.
    */
   readonly placement: UiPropertyDefinition<UiPlacement | undefined>;
   /**
@@ -7453,6 +7760,16 @@ declare const UiProperties: {
    * it is drawn at, is drawn directly.
    */
   readonly rasterize: UiPropertyDefinition<boolean>;
+  /**
+   * Hold this subtree while it cannot be read: out of view, or drawn
+   * smaller than `belowScale` of its size (a frame on a board zoomed
+   * far out). Held, nothing in it is laid out, described or drawn again,
+   * whatever its clocks and streams write; it is shown as it last was,
+   * which with `rasterize` is one copy of its pixels. It catches up on
+   * the frame it can be read again. `true` holds it only out of view.
+   * See `UiGraph.hold`.
+   */
+  readonly holdUnseen: UiPropertyDefinition<UiHoldUnseen | undefined>;
   readonly text: UiPropertyDefinition<string | undefined>;
   readonly image: UiPropertyDefinition<ImageBitmap | undefined>;
   /**
@@ -7573,6 +7890,8 @@ declare const UiProperties: {
    */
   readonly textStyle: UiPropertyDefinition<UiTextStyle | UiTypographyRole | undefined>;
   readonly contentColor: UiPropertyDefinition<UiColorValue | undefined>;
+  /** Values for keys of the application's own, provided to the subtree; see `UiProvision`. */
+  readonly provide: UiPropertyDefinition<readonly UiProvision<unknown>[] | undefined>;
   /**
    * Declares this node a size query container: its content size is
    * published to the subtree through `UiEnvironmentKeys.containerSize`,
@@ -7731,7 +8050,7 @@ type FlexItemProps = PropsOf<'flex' | 'flexGrow' | 'flexShrink' | 'flexBasis' |
 /** Where an element sits in a Grid. */
 type GridItemProps = PropsOf<'column' | 'columnSpan' | 'row' | 'rowSpan'>;
 type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'anchorPoint' | 'anchorRect' | 'placement' | 'anchorOffset'>;
-type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform' | 'rasterize'>;
+type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform' | 'rasterize' | 'holdUnseen'>;
 /**
  * Inherited text properties. Legal on any element: set on a container,
  * they cascade to the text below it.
@@ -7745,7 +8064,7 @@ type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'touchEmulation' |
  */
 type SemanticsProps = PropsOf<'role' | 'label' | 'description' | 'live' | 'states' | 'valueNow' | 'valueMin' | 'valueMax' | 'valueText' | 'posInSet' | 'setSize' | 'level' | 'rowIndex' | 'columnIndex' | 'rowCount' | 'columnCount' | 'activeDescendant' | 'controls' | 'autocomplete' | 'orientation'>;
 /** Environment values an element provides to its subtree. */
-type EnvironmentProps = PropsOf<'theme' | 'pointer' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets'>;
+type EnvironmentProps = PropsOf<'theme' | 'pointer' | 'textStyle' | 'contentColor' | 'containerSize' | 'insets' | 'provide'>;
 /**
  * Behaviour attached to an element without wrapping it: hover and
  * press state, a focus ring, a tooltip, drag. See `packages/core/src/modifiers`.
@@ -8380,6 +8699,29 @@ declare class UiGraph {
    * common case: themes change far less often than anything else.
    */
   hasEnvironmentDirty(): boolean;
+  /**
+   * Holds a subtree as it is: from now until `release`, nothing beneath
+   * `node` is marked dirty, so nothing there is laid out, described or
+   * drawn again, and a change to a provider above it stops at it. The
+   * marks are kept instead, and given again on release, so the subtree
+   * then catches up in one frame with everything that happened to it.
+   * `node` itself is not held: its own size and place still follow.
+   *
+   * For a subtree nobody can see, whose reactive sources would otherwise
+   * keep a whole tree busy: a design tool's board of hundreds of frames,
+   * each a live screen with its own clocks, most of them out of view or
+   * too small to read. Its bindings keep running and keep writing the
+   * values they produce, which costs a property write each; what it no
+   * longer costs is the layout, environment, semantics and paint every
+   * one of those writes set off. What the renderer has kept of it
+   * (`rasterize`) stays its picture, since nothing in it is dirty.
+   *
+   * Holding is not nested: a held node inside another's subtree is held
+   * by the outer one until that one is let go.
+   */
+  hold(node: UiNode): void;
+  /** Lets a held subtree go, and marks again what was marked while it was held. */
+  release(node: UiNode): void;
   markDirtyById(id: NodeId, flags: DirtyFlags): void;
   clearDirty(node: UiNode): void;
   /**
@@ -8430,15 +8772,10 @@ declare class UiGraph {
    */
   removeNodeProperty(node: UiNode, property: string, dirtyFlags?: DirtyFlags): boolean;
   /**
-   * Writes a property without consulting the node's transitions.
-   *
-   * What a transition's own per-frame writes go through: they are
-   * already the animation towards the target, so re-entering the
-   * transition check would have each frame start an animation towards
-   * the value it had just produced. Everything below this — the
-   * override cascade, the equality check, the dirty marking — is
-   * unchanged, so an animated value is overridable by a modifier
-   * exactly as a bound one is.
+   * Writes the element's value for a property: onto the node, or into
+   * the cascade under a modifier writing over it. The same as
+   * `updateNodeProperty`, kept by its name for the callers that write
+   * a value of the runtime's own, such as the root's pointer.
    */
   updateNodePropertyNow<T>(node: UiNode, property: string, value: T, dirtyFlags?: DirtyFlags): boolean;
   /**
@@ -8448,8 +8785,18 @@ declare class UiGraph {
    * Removing rather than writing a default is what lets a detaching
    * modifier restore inheritance: a node that never declared `color`
    * reads it from the environment again, as it did before.
+   *
+   * `snap` draws it at once, past any transition the node declares;
+   * see `UiPropertyOverride.snap`.
    */
-  applyResolvedProperty(node: UiNode, property: NodeProperty, present: boolean, value: unknown, dirtyFlags: DirtyFlags): boolean;
+  applyResolvedProperty(node: UiNode, property: NodeProperty, present: boolean, value: unknown, dirtyFlags: DirtyFlags, snap?: boolean): boolean;
+  /**
+   * Writes what a transition's frame drew, without consulting the
+   * transition again: the frame is already the animation towards the
+   * target, and re-entering it would start an animation towards the
+   * value it had just produced.
+   */
+  applyAnimatedValue(node: UiNode, property: NodeProperty, value: unknown, dirtyFlags: DirtyFlags): boolean;
   /**
    * Adds the environment flag to a write of `color` or of a text
    * style field, which a node provides to its subtree as well as
@@ -9761,6 +10108,10 @@ declare const UiEnvironmentKeys: {
    * with two windows provides one per window.
    */
   readonly insets: UiEnvironmentKey<UiInsetSource>;
+  /** The durations, easings and springs a name resolves to under a node; see `UiMotion`. */
+  readonly motion: UiEnvironmentKey<UiMotion>;
+  /** The clock the animations under a node run on; null is real time. See `UiClock`. */
+  readonly clock: UiEnvironmentKey<UiClock | null>;
 };
 //#endregion
 //#region src/environment/UiEnvironmentProvider.d.ts
@@ -10549,16 +10900,17 @@ declare class NodeTransitions implements UiNodeTransitions {
   write(property: NodeProperty, value: unknown, flags: DirtyFlags): boolean;
   /** Cancels everything, for a node leaving the tree or dropping the prop. */
   release(): void;
+  cancel(property: NodeProperty): void;
+  get declared(): ReadonlyMap<NodeProperty, UiTransitionSpec>;
   private stopProperty;
   /**
    * The cell one property animates through, kept for the life of the
    * node: the driver keys its running set by cell identity, so a fresh
    * adapter per write would leave the previous animation running.
    *
-   * Writing goes through `updateNodePropertyNow`, which is the path a
-   * plain write takes minus this class — so a modifier's override still
-   * sits on top of an animated value, exactly as it sits on top of a
-   * bound one.
+   * It writes what is drawn (`applyAnimatedValue`): the target already
+   * is the value the element and any modifier over it settled on, so a
+   * frame of the way there goes onto the node as it is.
    */
   private cellFor;
   private startAnimation;
@@ -11058,11 +11410,27 @@ declare class UiWheelController {
    * wheel of a burst land correctly even though the first could not.
    */
   lastWheelTarget: UiNode | null;
+  /** Where the last wheel event was, for the latch; see `latched`. */
+  private lastX;
+  private lastY;
   /**
    * 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;
+  /**
+   * The node the last wheel event landed on, while this one belongs to
+   * the same gesture: close behind it, with the pointer where it was.
+   * Null when it does not, and the point is tested afresh.
+   *
+   * A browser does the same, latching a wheel gesture to the element its
+   * first step landed on, and for the reason it matters here: testing the
+   * point asks for bounds that the gesture's own last step may have made
+   * out of date. A pinch over a design tool's board scales every name on
+   * it, and each step of it filled in the bounds of 1,800 names again,
+   * 4 ms, to find what the step before had found.
+   */
+  private latched;
   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
@@ -12460,6 +12828,15 @@ declare class UiEditingController {
    * Null when the node is not an editable, or has not been laid out.
    */
   caretRectOf(node: UiNode, offset?: number): CaretRect | null;
+  /**
+   * The caret position nearest a point, given as a pointer event gives
+   * it: where a press there would put the caret. For an application
+   * that opens a field over text the person pointed at, to start the
+   * caret where they pointed (`EditingService.select` puts it there).
+   *
+   * Null when the node is not an editable, or has not been laid out.
+   */
+  offsetNear(node: UiNode, x: number, y: number): number | null;
   /** Where a field, or a part of it in its own coordinates, is drawn; see `EditingHost.screenBox`. */
   private drawnBox;
   private layoutOf;
@@ -12956,6 +13333,10 @@ declare class UiHostFrameClock implements UiFrameClock {
   /** This thread's own `requestAnimationFrame`, or null where there is none. */
   private local;
   private localHandle;
+  /** This thread's own refreshes so far, which `watchLocal` counts on. */
+  private localRefreshes;
+  /** The timer standing by for a refresh that does not come; see `watchLocal`. */
+  private localWatch;
   /** Whether the page is hidden, when this thread's refreshes do not come. */
   private hidden;
   private readonly timeOrigin;
@@ -12993,6 +13374,29 @@ declare class UiHostFrameClock implements UiFrameClock {
   /** Whether this clock is driving itself from the compositor. */
   get isLocal(): boolean;
   requestFrame(): void;
+  /**
+   * Draws a wanted frame on a timer when this thread's own refreshes
+   * have stopped coming on a page that says it is shown.
+   *
+   * They do stop. A window that is shown but not composited (a browser
+   * pane hidden inside a desktop app, a window behind others on some
+   * systems) refreshes a page once a second or not at all, while
+   * `document.visibilityState` stays `visible`, so `setHidden` never
+   * hears of it; and a worker whose canvas the compositor is behind on
+   * is not given another refresh until it catches up. A frame asked for
+   * then waited for a refresh that did not come, and with no timer on
+   * this path, nothing else drew it: the application stopped answering,
+   * with its last frame on screen.
+   *
+   * One timer, a quarter of a second long, armed while frames are wanted
+   * and never more than one: it draws a frame only when not one refresh
+   * came in the whole of it. A compositor that is answering, however
+   * slowly the frames themselves run, always beats it, so it never
+   * stands in for a refresh that is coming (see the spec about a blocked
+   * host thread); it costs four wake-ups a second while something
+   * animates, against one per refresh for a per-frame watch.
+   */
+  private watchLocal;
   /**
    * 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
@@ -13155,6 +13559,22 @@ declare class UiHostFrameClock implements UiFrameClock {
   private cadenceMs;
   /** The interval to pace at while the host is absent: the display's, if it is known. */
   private selfPaceMs;
+  /**
+   * Draws the pending frame now, on this clock's timeline, and nothing
+   * when none is pending (`FrameService.flush`): for a tool that changed
+   * the screen and must read it drawn, in a window that may be sent no
+   * refreshes. It is not a refresh, so it teaches the clock nothing about
+   * the display. Handed to `tick` as one, with this thread's time, which
+   * is not the host's, it took the beat backwards; see `tick`.
+   */
+  flush(): void;
+  /**
+   * Draws the pending frame now, without waiting for a refresh: on the
+   * display's beat when frames are timed on it, so its time is the next
+   * refresh's and never one already drawn for; else at this moment, on
+   * the timeline the clock's frames are on.
+   */
+  private drawNow;
   cancelFrame(): void;
   private clearFallback;
   private deliver;
@@ -13491,6 +13911,13 @@ declare class LayoutEngine {
   private readonly absoluteBlocks;
   /** A positioned node, or the root, took a new box this pass; see `absoluteBlocks`. */
   private blockResized;
+  /**
+   * Which positioned nodes took a new box this pass, so only the nodes
+   * placed against one of them are placed again. Checking every one
+   * walked up from each to its block: a design tool's board has ten
+   * thousand of them, and one comment pin's label growing checked all.
+   */
+  private readonly resizedBlocks;
   /**
    * The nodes asking for `lift`, in the order they asked.
    *
@@ -13543,8 +13970,21 @@ declare class LayoutEngine {
    * from the first move to the last.
    */
   private layoutVersion;
-  /** The version `subtreeBounds` on the records was filled from. */
-  private boundsVersion;
+  /**
+   * Where the subtree bounds are out of date: everything, after a full
+   * pass; otherwise the nodes whose box or children or transform
+   * changed (`boundsMoved`) and the subtrees moved whole
+   * (`boundsShifted`), which `refreshSubtreeBounds` fills in again with
+   * their ancestors and nothing else.
+   */
+  private boundsWhole;
+  private readonly boundsMoved;
+  private readonly boundsShifted;
+  /**
+   * How many transforms changed: a transform moves no box, so it leaves
+   * `layoutVersion` alone, and `geometryVersion` adds these to it.
+   */
+  private transformMoves;
   constructor(textMeasurer?: TextMeasurer);
   recordFor(node: UiNode): LayoutRecord | undefined;
   /**
@@ -14096,6 +14536,8 @@ declare class LayoutEngine {
    * into the same visible space before comparing them.
    */
   private placeAnchored;
+  /** Lays a node exactly over a box, at its size, whatever size it asks for: `placement: 'over'`. */
+  private placeOver;
   /**
    * Places a measured node beside a box — an anchor's, or a point's of
    * no size — flipping to the opposite side when the named one would
@@ -14173,6 +14615,8 @@ declare class LayoutEngine {
    * chain the renderer composes on the way down, walked up; a turned box
    * is the box its corners span.
    */
+  /** How many changed nodes are refilled one by one before the whole tree is; see `WHOLE_BOUNDS_REFILL`. */
+  private wholeBoundsRefill;
   private projectBox;
   /**
    * A canvas box brought into the space an absolute child's record is
@@ -14189,6 +14633,8 @@ declare class LayoutEngine {
    * positioned ancestor's, else the layout root's.
    */
   private containingBlockOf;
+  /** The positioned ancestor, or the root, that an absolute node is placed against. */
+  private containingBlockNodeOf;
   /**
    * Records the children's paint order when it differs from tree order,
    * so renderers and hit testing agree on who is on top: by zIndex, and
@@ -14567,8 +15013,28 @@ interface NotifiedLayout {
 declare class LayoutNotifier {
   private readonly listeners;
   private readonly last;
+  /**
+   * Listeners told about the node's place in the layout and its scroll
+   * offset, and not about where it is drawn (`addFlow`).
+   */
+  private readonly flowListeners;
+  private readonly flowLast;
   /** Registers a listener; the returned function removes it. */
   add(node: UiNode, listener: (box: LayoutBox) => void): () => void;
+  /**
+   * Registers a listener told when the node's laid-out box or its own
+   * scroll offset changes, and not when a scroll or a transform above it
+   * moves it on screen; the returned function removes it.
+   *
+   * Most listeners are this kind: a size container, a breakpoint, a
+   * layout animation, a scroll position read only the node's own box
+   * and offset. Told of every move on screen, each of them was asked
+   * on every step of a pan over a design tool's board, 2,600 of them,
+   * to find nothing it reads had changed; and each answer was where
+   * the node was drawn, worked out through every ancestor. Its place in
+   * the layout is its record, read at once.
+   */
+  addFlow(node: UiNode, listener: (box: LayoutBox) => void): () => void;
   get size(): number;
   /** Whether anything is listening, so a frame can skip the walk. */
   isEmpty(): boolean;
@@ -14576,7 +15042,7 @@ declare class LayoutNotifier {
    * Calls the listeners of every watched node whose box or scroll
    * offset differs from what it was last told about.
    */
-  notify(read: (node: UiNode) => NotifiedLayout): void;
+  notify(read: (node: UiNode) => NotifiedLayout, readFlow?: (node: UiNode) => NotifiedLayout): void;
   /** Drops a removed node's listeners, so nothing keeps it alive. */
   handleNodeRemoved(node: UiNode): void;
 }
@@ -14901,6 +15367,18 @@ declare function bundle(...parts: readonly (UiModifier | UiModifierBundle)[]): U
 declare const noModifiers: UiModifierBundle;
 //#endregion
 //#region src/modifiers/interaction.d.ts
+/** A pointer or keyboard state a tool draws an element in without the pointer or the keyboard. */
+type UiShownAs = 'hovered' | 'pressed' | 'focused';
+/**
+ * Draws what is under a node as though it were hovered, pressed or
+ * focused: every `interactive` modifier there shows its hover or press
+ * look, and every `focusRing` its ring. What a design tool draws a
+ * component's pointer states with, beside its other states, where no
+ * pointer is over it. Read as each modifier attaches, so a node drawn
+ * under it starts so and stays so; the pointer still adds its own.
+ * Pressed is hovered too, as a press under a pointer is.
+ */
+declare const ShownAsKey: UiEnvironmentKey<UiShownAs | null>;
 /**
  * Pointer state, as a property anything can read, and the property
  * writes that follow from it.
@@ -15642,10 +16120,10 @@ interface SvgXmlElement {
  *
  * What a design tool exports is what is read: shapes and paths, groups
  * and `<use>`, transforms, solid fills and strokes with their
- * opacities, linear and radial gradients, clip paths, a `<style>` of
- * simple selectors, and nested `<svg>`. What is not drawn yet is named
- * in `unsupported`, so a file that leans on it can say so rather than
- * look subtly wrong.
+ * opacities, linear and radial gradients, clip paths, masks, a filter
+ * that is one drop shadow, a `<style>` of simple selectors, and nested
+ * `<svg>`. What is not drawn yet is named in `unsupported`, so a file
+ * that leans on it can say so rather than look subtly wrong.
  */
 interface SvgDocument {
   /** The `<svg>` element. */
@@ -15655,11 +16133,16 @@ interface SvgDocument {
   readonly height: number;
   /** The region of the drawing's own coordinates that fills that size. */
   readonly viewBox: SvgRect;
-  /** Every element with an `id`, for `<use>`, gradients and clip paths. */
+  /** Every element with an `id`, for `<use>`, gradients, clip paths, masks and filters. */
   readonly ids: ReadonlyMap<string, SvgXmlElement>;
   /** The rules of its `<style>` elements, in document order. */
   readonly rules: readonly SvgStyleRule[];
-  /** What the file uses that is not drawn: `text`, `filter`, `mask` and so on, once each. */
+  /**
+   * What the file uses that is not drawn: `text`, `image`, `marker` and
+   * so on, once each. `filter` is a filter that is anything but one
+   * `<feDropShadow>`, or a `filter` that names something else; `mask`
+   * is a `mask` that names something other than a `<mask>`.
+   */
   readonly unsupported: readonly string[];
 }
 interface SvgRect {
@@ -17974,6 +18457,17 @@ type PaintOp = {
 } | {
   readonly op: 'blur';
   readonly radius: number;
+} | {
+  readonly op: 'beginMaskedLayer';
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+} | {
+  readonly op: 'layerMask';
+  readonly mode: PaintMaskMode;
+} | {
+  readonly op: 'endMaskedLayer';
 } | {
   readonly op: 'fill';
   readonly rule: PaintFillRule;
@@ -18057,6 +18551,9 @@ declare class PaintRecorder implements PaintSurface {
   lineDash(segments: readonly number[], offset?: number): void;
   alpha(value: number): void;
   blur(radius: number): void;
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  layerMask(mode?: PaintMaskMode): void;
+  endMaskedLayer(): void;
   fill(rule?: PaintFillRule): void;
   stroke(): void;
   clip(rule?: PaintFillRule): void;
@@ -18146,12 +18643,74 @@ interface PaintContext2D {
    * rather than none.
    */
   filter?: string;
+  /**
+   * What a masked layer needs of a context, all optional for the reason
+   * `filter` is: a host or a double without them draws the layer's
+   * content unmasked. The context drawn into reads and sets its whole
+   * transform, to place a layer in device pixels; a layer's own canvas
+   * also composites and reads its pixels back.
+   */
+  getTransform?(): PaintMatrix;
+  setTransform?(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  globalCompositeOperation?: string;
+  getImageData?(x: number, y: number, width: number, height: number): PaintPixels;
+  putImageData?(pixels: PaintPixels, x: number, y: number): void;
   fillStyle: string | PaintGradient;
   strokeStyle: string | PaintGradient;
   font: string;
   textAlign: 'left' | 'center' | 'right';
   textBaseline: 'alphabetic';
 }
+/** An affine matrix to device pixels, `a b c d e f`, as `getTransform` reports one. */
+interface PaintMatrix {
+  readonly a: number;
+  readonly b: number;
+  readonly c: number;
+  readonly d: number;
+  readonly e: number;
+  readonly f: number;
+}
+/** A context's pixels, unpremultiplied RGBA, as `getImageData` reads them. */
+interface PaintPixels {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8ClampedArray;
+}
+/**
+ * The canvas a picture is drawn into, and the bitmap it becomes.
+ *
+ * `IconCanvas`'s sibling, and injectable for the same two reasons: the
+ * suite has no `OffscreenCanvas`, and a host that lacks one should
+ * fail by drawing nothing rather than by throwing in a frame.
+ *
+ * `take()` is synchronous, which is the whole reason the default is
+ * `transferToImageBitmap` and not `createImageBitmap`. An asynchronous
+ * raster would put the picture a frame behind its inputs and would
+ * need a way to ask for another frame from inside a renderer, which no
+ * renderer has and none should.
+ */
+interface PaintCanvas {
+  context(): PaintContext2D | null;
+  take(): UiImage;
+}
+type PaintCanvasFactory = (width: number, height: number) => PaintCanvas | null;
+/**
+ * Where a target's masked layers come from: a canvas per layer, and the
+ * rectangle of the context drawn into, in its device pixels, that a
+ * layer is cut to. Without one a target draws a layer's content
+ * unmasked.
+ */
+interface PaintLayers {
+  readonly create: PaintCanvasFactory;
+  readonly bounds: PaintDeviceRect;
+}
+/** A rectangle in device pixels. */
+interface PaintDeviceRect {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
 /** The part of a canvas gradient a picture uses. */
 interface PaintGradient {
   addColorStop(offset: number, color: string): void;
@@ -18180,8 +18739,8 @@ interface PaintResolver {
  * picture's cache key.
  */
 declare class PaintTarget implements PaintSurface {
-  private readonly ctx;
   private readonly resolver;
+  private readonly layerSource?;
   /**
    * The pending blur radius per save level.
    *
@@ -18191,7 +18750,17 @@ declare class PaintTarget implements PaintSurface {
    */
   private readonly blurStack;
   private blurRadius;
-  constructor(ctx: PaintContext2D, resolver: PaintResolver);
+  /** The context drawn into now: the one given, or a layer's while its content or mask is drawn. */
+  private ctx;
+  /** The masked layers begun and not yet ended, innermost last. */
+  private readonly layers;
+  /**
+   * How many layers are drawing nothing at the moment: one cut to
+   * nothing, or a mask a host could not keep apart. Fills, strokes,
+   * text and images are dropped while it is above zero.
+   */
+  private suppressed;
+  constructor(ctx: PaintContext2D, resolver: PaintResolver, layerSource?: PaintLayers | undefined);
   save(): void;
   restore(): void;
   translate(x: number, y: number): void;
@@ -18223,7 +18792,25 @@ declare class PaintTarget implements PaintSurface {
   miterLimit(limit: number): void;
   lineDash(segments: readonly number[], offset?: number): void;
   alpha(value: number): void;
+  /**
+   * A canvas's filter is measured in device pixels whatever the
+   * transform, so the radius is scaled by the transform's here, where
+   * there is one to read.
+   */
   blur(radius: number): void;
+  /**
+   * The content is drawn into a canvas of its own, the size of the
+   * layer's rectangle in device pixels and cut to the part of the
+   * context drawn into that it covers, under the same transform less
+   * the canvas's corner. A fresh canvas per layer, sized once: drawing
+   * into a canvas just blended from makes Chrome copy it first (see
+   * `GroupOpacity.ts`).
+   */
+  beginMaskedLayer(x: number, y: number, width: number, height: number): void;
+  layerMask(mode?: PaintMaskMode): void;
+  endMaskedLayer(): void;
+  /** A canvas for a layer's content or mask, placed and cut as the layer is; null where none can be had. */
+  private openLayerCanvas;
   fill(rule?: PaintFillRule): void;
   stroke(): void;
   clip(rule?: PaintFillRule): void;
@@ -18232,24 +18819,6 @@ declare class PaintTarget implements PaintSurface {
 }
 //#endregion
 //#region src/rendering/PaintPicture.d.ts
-/**
- * The canvas a picture is drawn into, and the bitmap it becomes.
- *
- * `IconCanvas`'s sibling, and injectable for the same two reasons: the
- * suite has no `OffscreenCanvas`, and a host that lacks one should
- * fail by drawing nothing rather than by throwing in a frame.
- *
- * `take()` is synchronous, which is the whole reason the default is
- * `transferToImageBitmap` and not `createImageBitmap`. An asynchronous
- * raster would put the picture a frame behind its inputs and would
- * need a way to ask for another frame from inside a renderer, which no
- * renderer has and none should.
- */
-interface PaintCanvas {
-  context(): PaintContext2D | null;
-  take(): UiImage;
-}
-type PaintCanvasFactory = (width: number, height: number) => PaintCanvas | null;
 /** What a painted frame did, for `PaintPicture.budget.spec.ts`. */
 interface PaintStats {
   /** How many times a painter's `draw` ran. */
@@ -20422,5 +20991,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp4AudioTrack as $, EditingControllerOptions as $a, ResponsiveProps as $c, darkTheme as $d, UiTextLink as $f, createTween as $g, borderRadiusCorners as $h, parseCrossAxisAlignment as $i, UiPropertyValueOf as $l, slideFrom as $m, BreakpointArgs as $n, HitTester as $o, UiModifierTeardown as $p, pinchable as $r, drawText as $s, registerFontStack as $t, hasVisualState as $u, offsetAtPointIn as A, linear as A_, UiHostFrameClock as Aa, selectableTextOf as Ac, FrLength as Ad, UiBoxShadow as Af, TextWrap as Ag, UiContentDistribution as Ah, noModifiers as Ai, EditableTextProps as Al, UiPointerEvent as Am, UiRenderer as An, UiScrollability as Ao, containerBands as Ap, IconRasterizerOptions as Ar, EDITOR_PROP as As, createTextCache as At, LazyGridOptions as Au, markNow as B, isSubtreeInert as Ba, offsetAtPoint as Bc, isPercentLength as Bd, UiTypography as Bf, UiTransitionValue as Bg, UiPosition as Bh, propertyIsInherited as Bi, PositionProps as Bl, MOTION_REST as Bm, createCanvasSurface as Bn, resetTransitionWarnings as Bo, edgeField as Bp, DefaultImageResolver as Br, EditingPlatform as Bs, isWebGPUAvailable as Bt, VirtualViewport as Bu, hasTextLinks as C, normalizeColor as C_, labelNode as Ca, normalizeVerticalAlign as Cc, UiRadialGradient as Cd, relativeLuminance as Cf, TextLineRun as Cg, decorationRect as Ch, hoverable as Ci, UiGraphBuilder as Cl, UiGestureEvent as Cm, CanvasTextMeasurer as Cn, KeyboardControllerOptions as Co, UiInsets as Cp, ImageSources as Cr, findMatchesIn as Cs, RenderList as Ct, SheetSourceArgs as Cu, setLinkHover as D, UiEasing as D_, UiFrameClock as Da, TextRange as Dc, radialGradient as Dd, defaultShadows as Df, TextRunMeasurer as Dg, UiAlignment as Dh, pressable as Di, ColumnProps as Dl, UiPasteEvent as Dm, LayerCanvasFactory as Dn, ScrollContainerState as Do, UiContainerSize as Dp, IconCanvas as Dr, EnvironmentNotifier as Ds, TEXTURED_STRIDE_FLOATS as Dt, VIRTUAL_SHEET_PROP as Du, linkRunAtPointIn as E, rgba as E_, UiAnimationFrameClock as Ea, TEXT_SELECTION_PROP as Ec, linearGradient as Ed, UiShadows as Ef, TextOverflow as Eg, UI_SUBGRID_AXES as Eh, measureFlow as Ei, ButtonProps as El, UiKeyboardEvent as Em, traceRoundedRect as En, UiPointerController as Eo, observeViewportInsets as Ep, mediaLoadsInFlight as Er, UiEnvironmentKeys as Es, TEXTURED_STRIDE_BYTES as Et, UiVirtualSheetOptions as Eu, UiFrameCallback as F, isNodeFocusable as Fa, RunMeasure as Fc, auto as Fd, boxShadowRadius as Ff, findEnvironmentKey as Fg, UiGridAutoFlow as Fh, findPropertyDefinition as Fi, GridProps as Fl, UiWheelEvent as Fm, OverlayShape as Fn, UiGestureRecognizer as Fo, UiEditingGroup as Fp, SvgResolver as Fr, isMultiline as Fs, GlyphSlot as Ft, VIRTUAL_INDEX_PROP as Fu, VttTrack as G, PlatformEventTarget as Ga, lineEndAt as Gc, UiPropertyDefinition as Gd, typographyEqual as Gf, AnimatedCell as Gg, UiTextOverflowValue as Gh, GridPlacement as Gi, StackProps as Gl, ResolvedMotionState as Gm, resolveString as Gn, writeOverrideProperty as Go, UiModifierSet as Gp, ContextMenuOptions as Gr, CanvasTextStyle as Gs, WebGPURenderer as Gt, MAX_MEASURES_PER_CHILD as Gu, performanceMarksEnabled as H, resolveCursor as Ha, offsetForVerticalMove as Hc, percent as Hd, UiTypographyRole as Hf, normalizeTransition as Hg, UiSubgridAxis as Hh, propertyValuesEqualByName as Hi, Reactive as Hl, MotionState as Hm, resolveNumber as Hn, overrideSources as Ho, UiModifierEnvironment as Hp, ImageResolver as Hr, detectEditingPlatform as Hs, CapturedFrame as Ht, UiVideoSurface as Hu, UiScheduler as I, isNodeHitTestable as Ia, caretRectFor as Ic, fr as Id, boxShadowReach as If, UiNodeType as Ig, UiObjectFit as Ih, getPropertyNames as Ii, IdentityProps as Il, noKeyModifiers as Im, drawOverlayShapes as In, PinchRecognizerOptions as Io, UiGroupEdit as Ip, isSvgSource as Ir, isReadOnly as Is, GlyphUpload as It, VIRTUAL_LEAD_PROP as Iu, ByteSource as J, capturePointer as Ja, nextWordEnd as Jc, TOUCH_TARGET as Jd, UiFontStyle as Jf, UiReducedMotionPolicy as Jg, UiVerticalAlign as Jh, sizeGridTracks as Ji, TypographyProps as Jl, pop as Jm, sameArgs as Jn, SelectionControllerOptions as Jo, UiModifier as Jp, contextMenu as Jr, TextLinePlacement as Js, WebGPUSurface as Jt, UiLayoutProtocol as Ju, cueAt as K, PlatformSurface as Ka, lineStartAt as Kc, defineProperty as Kd, UiFontKerning as Kf, UiAnimation as Kg, UiTextWrapValue as Kh, GridTrack as Ki, TextContentProps as Kl, fade as Km, ThemeTokenTarget as Kn, FindHost as Ko, UiUnknownModifierPropertyError as Kp, ShortcutOptions as Kr, PlacedTextRun as Ks, WebGPURendererOptions as Kt, UiLayoutChild as Ku, UiSchedulerOptions as L, isNodeInert as La, lineIndexAtY as Lc, isAutoLength as Ld, boxShadowValuesEqual as Lf, DirtyFlags as Lg, UiOverflow as Lh, inheritedPropertyFlags as Li, InteractionProps as Ll, wheelDeltaYOf as Lm, labelOrigin as Ln, UiPinchRecognizer as Lo, UiTextPosition as Lp, SvgDocument as Lr, nextCaretToggle as Ls, WebGPUGlyphAtlas as Lt, VIRTUAL_WINDOW_PROP as Lu, paragraphGeometryFrom as M, UiManualFrameClock as Ma, setSelectionRange as Mc, PercentLength as Md, UiShadowName as Mf, UiEnvironment as Mg, UiDirection as Mh, accumulatedOffsetTo as Mi, FlexContainerProps as Ml, UiSelectionChangeEvent as Mm, RenderChanges as Mn, isScrollContainer as Mo, UiTextInput as Mp, iconKey as Mr, editorFor as Ms, textRuns as Mt, LazyListOptions as Mu, selectionRectsIn as N, UiTimerFrameClock as Na, CaretRect as Nc, UiLength as Nd, boxShadow as Nf, UiEnvironmentKey as Ng, UiFlexWrap as Nh, contentOffset as Ni, FlexItemProps as Nl, UiTextChangeEvent as Nm, RenderContext as Nn, GestureInput as No, UiTextInputState as Np, DefaultSvgResolver as Nr, editorOf as Ns, GlyphShaper as Nt, LazySourceArgs as Nu, ParagraphGeometry as O, cubicBezier as O_, UiFrameClockFactory as Oa, clearSelectionRange as Oc, validateGradient as Od, shadowsEqual as Of, TextRunSpan as Og, UiBorderRadiusValue as Oh, UiModifierBundle as Oi, CommonProps as Ol, UiPinchEvent as Om, ScrollLayerStats as On, ScrollSink as Oo, UiContainerSizeSource as Op, IconContext as Or, CARET_BLINK_MS as Os, TextRunDraw as Ot, sheetSource as Ou, wordRangeIn as P, UiTimerFrameClockOptions as Pa, PlacedLine as Pc, UiTrackSize as Pd, boxShadowArraysEqual as Pf, createEnvironmentKey as Pg, UiFontWeight as Ph, closestPropertyName as Pi, GridItemProps as Pl, UiWheelDeltaMode as Pm, LABEL_PADDING_X as Pn, GestureRecognizerOptions as Po, textInputOf as Pp, DefaultSvgResolverOptions as Pr, isEditableNode as Ps, GLYPH_SUBPIXEL_PHASES as Pt, UiVirtualWindow as Pu, rangeSource as Q, touchActionFor as Qa, Responsive as Qc, UiTheme as Qd, UiTextDecoration as Qf, UiTweenOptions as Qg, borderRadius as Qh, parseAlignContent as Qi, UiPropertyName as Ql, slideDown as Qm, publishInset as Qn, HitTestResult as Qo, UiModifierHost as Qp, ZoomState as Qr, createCanvasTextStyle as Qs, fontStackFor as Qt, defaultVisualState as Qu, MARK_PREFIX as R, isNodeSelectable as Ra, lineIndexForOffset as Rc, isFrLength as Rd, boxShadowsEqual as Rf, AnimationDriver as Rg, UiPlacement as Rh, inheritedPropertyNames as Ri, PaintElementProps as Rl, DirtyNodeSet as Rm, CanvasHost as Rn, FocusNotifier as Ro, adjacentField as Rp, SvgRect as Rr, syncEditorValue as Rs, WebGPUTextureCache as Rt, VirtualItemMeasure as Ru, clearLinkHover as S, colorsEqual as S_, formatExplanation as Sa, normalizeTextAlign as Sc, UiLinearGradient as Sd, raiseContrast as Sf, TextLine as Sg, decorationColor as Sh, InteractiveOptions as Si, UiChildrenBinding as Sl, UiFocusEvent as Sm, LayoutInspectorOptions as Sn, shortcutKeyCaps as So, UiInsetSource as Sp, ImageSourceArgs as Sr, FindOptions as Ss, RenderCommand as St, SheetRowRenderer as Su, linkOf as T, rgb8 as T_, UiFrame as Ta, DEFAULT_LINE_HEIGHT_FACTOR as Tc, gradientsEqual as Td, densityFactors as Tf, TextMeasurer as Tg, paintsAfterChildren as Th, measure as Ti, BoxProps as Tl, UiKeyModifiers as Tm, Canvas2DRendererOptions as Tn, PointerControllerOptions as To, noInsets as Tp, imageSource as Tr, provideEnvironment as Ts, ScissorRect as Tt, UiVirtualSheet as Tu, setPerformanceMarks as U, CanvasPlatformSurface as Ua, selectionRects as Uc, repeat as Ud, defaultTypography as Uf, spring as Ug, UiTextAlign as Uh, GridContribution as Ui, RowProps as Ul, MotionStateInput as Um, resolveProperty as Un, resetOverrideWarnings as Uo, UiModifierFocus as Up, AnimateLayoutOptions as Ur, isPrintable as Us, DrawStats as Ut, isVideoSurface as Uu, measureSpan as V, pointerEventsOf as Va, offsetAtX as Vc, minmax as Vd, UiTypographyExtensions as Vf, assertTransitionMap as Vg, UiSelfAlignment as Vh, propertyNarrowers as Vi, PropsOf as Vl, MotionChannel as Vm, resolveBoolean as Vn, clearOverrideProperty as Vo, editingGroupOf as Vp, DefaultImageResolverOptions as Vr, commandForKey as Vs, WebGPUError as Vt, lazySource as Vu, VttCue as W, PlatformAdapterOptions as Wa, graphemeBoundaries as Wc, resolveLength as Wd, isTypographyRole as Wf, tween as Wg, UiTextDirection as Wh, GridItemRequest as Wi, ScrollViewProps as Wl, MotionTiming as Wm, resolvePropertyByName as Wn, writeDeclaredProperty as Wo, UiModifierLayout as Wp, animateLayout as Wr, EditableLayout as Ws, RenderHooks as Wt, videoFrameSize as Wu, RangeSourceOptions as X, pointerDeviceOf as Xa, previousWordStart as Xc, UiThemeTouch as Xd, UiResolvedTextSpan as Xf, UiSpringOptions as Xg, UiBorderRadius as Xh, CrossAxisAlignment as Xi, UiNodeRef as Xl, rotateFrom as Xm, PublishInsetArgs as Xn, UiSelectionController as Xo, defineModifier as Xp, shortcuts as Xr, applyCanvasTextStyle as Xs, bumpFontStack as Xt, UiVisualState as Xu, DEFAULT_BLOCK_SIZE as Y, isImeKey as Ya, previousGraphemeStart as Yc, UiPointer as Yd, UiFontVariant as Yf, UiSpring as Yg, validateSubgrid as Yh, AlignContent as Yi, UiEventProps as Yl, resolveMotionState as Ym, InsetPaddingArgs as Yn, SelectionHost as Yo, UiModifierKind as Yp, shortcut as Yr, TextRunRect as Ys, createWebGPUSurface as Yt, isLayoutProtocol as Yu, bufferSource as Z, prepareInputSurface as Za, wordRangeAt as Zc, withPointer as Zd, UiSpannedText as Zf, UiTween as Zg, UiBorderRadiuses as Zh, MainAxisAlignment as Zi, UiProperties as Zl, scaleFrom as Zm, insetPadding as Zn, HitTestLayoutReader as Zo, isUiModifier as Zp, PinchableOptions as Zr, buildFontString as Zs, clearFontStacks as Zt, UiVisualStateSet as Zu, buildSemanticsTree as _, UiBasicColors as __, RelayoutExplanation as _a, VerticalAlign as _c, ResolvedGradient as _d, withThemeExtension as _f, FixedMetricsOptions as _g, UiPropertyOverrides as _h, borderShapes as _i, BindingId as _l, UiListenerErrorReporter as _m, drawSvg as _n, UiShortcutRegistry as _o, scaleSpacing as _p, MotionArgs as _r, TEXT_MATCHES_PROP as _s, INSTANCE_STRIDE_FLOATS as _t, EditableTextModel as _u, diffSemantics as a, defaultMotion as a_, proportionalFontMetrics as aa, textRunDecorations as ac, PaintLineJoin as ad, UiUnits as af, UiShapeExtensions as ag, LayoutResult as ah, dropTarget as ai, Box as al, UiChild as am, PaintContext2D as an, EXTERNAL_FILES as ao, editableSpansOf as ap, scrollPosition as ar, SCROLLBAR_THICKNESS as as, Mp3Frame as at, UiOrientation as au, semanticsMemory as b, colorToRgba as b_, describeOverrides as ba, createPaintState as bc, UiGradientOffset as bd, contrastRatio as bf, ParagraphTextMeasurer as bg, DecorationShape as bh, focusRing as bi, UiEventBinding as bl, UiCompositionEvent as bm, InspectorOverlay as bn, formatShortcut as bo, UiInsetEdge as bp, sharedElement as br, setMatchRanges as bs, PrimitiveCommand as bt, SheetHeaderRenderer as bu, SemanticsMemory as c, interpolateNumber as c_, SCROLLBAR_FADE_MS as ca, DEFAULT_FONT_FAMILY as cc, PaintTextStyle as cd, unitsEqual as cf, defaultShapes as cg, TightenOptions as ch, DraggableOptions as ci, EditableText as cl, isComponentLikeElement as cm, PaintTarget as cn, UiDragState as co, resolvedSpansOf as cp, VideoState as cr, ScrollbarThumb as cs, readMp3Header as ct, UiSemanticStates as cu, SemanticsRewalk as d, UiTransform as d_, AxisExplanation as da, DEFAULT_TEXT_COLOR as dc, inputsEqual as dd, UiThemeExtensions as df, UiColors as dg, tightenConstraints as dh, clickOutside as di, Row as dl, isUiElement as dm, PaintOp as dn, UiDroppedFile as do, spansDifferOnlyInPaint as dp, DefaultVideoResolver as dr, scrollRange as ds, Affine as dt, normalizeStates as du, UiDurationToken as e_, parseMainAxisAlignment as ea, fillTextRects as ec, visualState as ed, lightTheme as ef, borderRadiusEqual as eg, slideUp as eh, AutoScrollOptions as ei, LazyColumn as el, FocusOptions as em, PaintCanvas as en, EditingHost as eo, UiTextMetrics as ep, SizeContainerArgs as er, UiHitTester as es, Mp4Sample as et, UiPropertyValues as eu, SemanticsSpan as f, UiTransforms as f_, CustomLayoutExplanation as fa, ObjectFit as fc, paintValuesEqual as fd, defineThemeExtension as ff, colorsEqualPalette as fg, NodeId as fh, autoFocus as fi, ScrollView as fl, UiPropValue as fm, PaintRecorder as fn, UiFileDropMessage as fo, textContentOf as fp, DefaultVideoResolverOptions as fr, scrollbarThumb as fs, CLIP_STRIDE_BYTES as ft, statesEqual as fu, buildSemanticsSubtree as g, transformsEqual as g_, OverrideSources as ga, TextAlign as gc, MAX_GRADIENT_STOPS as gd, themeExtensionsEqual as gf, CharacterCountTextMeasurer as gg, UiPropertyOverride as gh, FocusRingOptions as gi, UiDefinition as gl, UiInputDispatcher as gm, SvgFit as gn, UiShortcutBinding as go, defaultSpacing as gp, canDecodeVideo as gr, SubtreeBounds as gs, INSTANCE_STRIDE_BYTES as gt, EditUnit as gu, UiSemanticsRecord as h, transformIsIdentity as h_, LayoutStateExplanation as ha, PaintTextSpan as hc, GradientPaint as hd, themeExtension as hf, LayoutRecord as hg, UiNodeTransitions as hh, Decorations as hi, createElement as hl, UiEventListenerOptions as hm, SvgDrawOptions as hn, UiShortcut as ho, UiSpacing as hp, VideoResolver as hr, scrollsFromRight as hs, GlyphCommand as ht, CompositionRange as hu, UiSemanticsPatch as i, UiSpringToken as i_, layoutParagraph as ia, textRunBackgrounds as ic, PaintLineCap as id, UiLengths as if, uniformBorderRadius as ig, LayoutBox as ih, dragSource as ii, LazyRow as il, ComponentLikeElement as im, paintPictures as in, UiTouchScroller as io, defaultTextStyle as ip, ScrollPositionArgs as ir, SCROLLBAR_MIN_THUMB as is, Mp3Format as it, UiLiveRegion as iu, paragraphGeometry as j, steps as j_, UiHostFrameClockOptions as ja, selectionRangeOf as jc, MinMaxTrack as jd, UiBoxShadows as jf, spannedRunsFor as jg, UiCursor as jh, Transform as ji, EnvironmentProps as jl, UiPointerKind as jm, LayoutReader as jn, UiWheelController as jo, unknownContainerSize as jp, IconSpec as jr, caretVisibleAt as js, glyphCount as jt, LazyItemRenderer as ju, hasDrawnText as k, easings as k_, UiFrameTime as ka, selectableTextNodes as kc, AutoLength as kd, BOX_SHADOW_BLUR_REACH as kf, TextRunStyle as kg, UiColorValue as kh, bundle as ki, ContainerProps as kl, UiPointerDevice as km, RendererBackend as kn, UiScrollBehavior as ko, bandOf as kp, IconRasterizer as kr, CARET_WIDTH as ks, buildRenderList as kt, LazyAxis as ku, SemanticsPlacement as l, interpolateTransform as l_, SCROLLBAR_LINGER_MS as la, DEFAULT_FONT_SIZE as lc, UiPaint as ld, UiThemeExtension as lf, isShapeName as lg, clampSize as lh, draggable as li, Grid as ll, isObservable$1 as lm, tracePathData as ln, UiDropEffect as lo, spanAtOffset as lp, VideoTransport as lr, scrollBounds as ls, splitMp3Frames as lt, isUiRole as lu, UiSemanticsMap as m, transform as m_, LayoutExplanation as ma, PaintState as mc, UiImage as md, noThemeExtensions as mf, lightColors as mg, UiNode as mh, BordersOptions as mi, Text as ml, UiEventListener as mm, replayPaint as mn, ShortcutRegistryOptions as mo, textStylesEqual as mp, VideoPlayback as mr, scrollbarZoneAt as ms, CommandKind as mt, validateStates as mu, UiSemanticsBox as n, UiMotion as n_, parseFlexDirection as na, runCanvasStyleInto as nc, PaintBox as nd, withContrast as nf, borderRadiusValuesEqual as ng, UiSharedElements as nh, DropTargetOptions as ni, LazyGridProps as nl, UiFocusManager as nm, PaintPictureCache as nn, UiEditingController as no, UiTextSpan as np, sizeContainer as nr, SCROLLBAR_HOVER_ZONE as ns, demuxMp4Audio as nt, UI_SEMANTIC_STATES as nu, dropIndexShifts as o, UiInterpolator as o_, LayoutNotifier as oa, Canvas2DContext as oc, PaintSurface as od, defaultUnits as of, UiShapeName as og, LayoutStats as oh, reorderable as oi, Button as ol, UiElement as om, PaintGradient as on, UiDragPayload as oo, flattenTextSpans as op, VideoClock as or, ScrollBounds as os, Mp3Frames as ot, UiRole as ou, TEXT_RUN_ID_SEPARATOR as p, parseTransform as p_, Edges as pa, PaintBoxShadow as pc, pathValuesEqual as pd, hasThemeExtension as pf, darkColors as pg, NodeProperty as ph, BorderEdge as pi, Stack as pl, UiProps as pm, PaintRecording as pn, dragSessionFor as po, textSpansEqual as pp, RangeResponse as pr, scrollbarThumbs as ps, CLIP_STRIDE_FLOATS as pt, validateRole as pu, parseWebVtt as q, UiPlatformAdapter as qa, nextGraphemeEnd as qc, propertyValuesEqual as qd, UiFontStretch as qf, UiAnimationOptions as qg, UiThemeColorName as qh, placeGridItems as qi, TextProps as ql, isMotionRest as qm, themeTokens as qn, UiFindController as qo, assertModifierList as qp, ShortcutsOptions as qr, SpanPaint as qs, WebGPUCanvasHost as qt, UiLayoutContext as qu, UiSemanticsUpdate as r, UiSpringSpec as r_, ELLIPSIS as ra, runFontString as rc, PaintFillRule as rd, withDensity as rf, normalizeBorderRadius as rg, Constraints as rh, ReorderableOptions as ri, LazyListProps as rl, ComponentResolver as rm, PaintStats as rn, TouchScrollerOptions as ro, UiTextStyle as rp, ScrollOffset as rr, SCROLLBAR_INSET as rs, demuxMp4Video as rt, UiAutocomplete as ru, recordsEqual as s, interpolateColor as s_, LayoutEngine as sa, Canvas2DGradient as sc, PaintTextAlign as sd, lengths as sf, UiShapes as sg, Size as sh, DragOffset as si, Column as sl, UiSourceLocation as sm, PaintResolver as sn, UiDragSession as so, hiddenRangesOf as sp, VideoSourceArgs as sr, ScrollbarAxis as ss, Mp3Header as st, UiSemanticState as su, UiSemanticsAction as t, UiEasingToken as t_, FlexDirection as ta, layoutTextLines as tc, visualStatesEqual as td, themesEqual as tf, borderRadiusIsZero as tg, SharedClaim as th, DragSourceOptions as ti, LazyGrid as tl, FocusSource as tm, PaintCanvasFactory as tn, EditingState as to, UiTextRange as tp, breakpoint as tr, UiPoint as ts, Mp4VideoTrack as tt, UI_ROLES as tu, SemanticsReuse as u, interpolatorFor as u_, ScrollAdjustment as ua, DEFAULT_FONT_WEIGHT as uc, UiPath as ud, UiThemeExtensionOptions as uf, shapesEqual as ug, constraintsEqual as uh, ClickOutsideOptions as ui, Paint as ul, isUiChild as um, EMPTY_RECORDING as un, UiDropZone as uo, spannedTextOf as up, videoSource as ur, scrollLeaderOf as us, WebGPUGlyphPages as ut, isUiSemanticState as uu, rewalkSemantics as v, UiColor as v_, SizeDecision as va, colorToCss as vc, ResolvedGradientStop as vd, HighContrastOptions as vf, FontMetrics as vg, DecorationFill as vh, borders as vi, UiBinding as vl, MOUSE_POINTER as vm, svgPaint as vn, UiShortcutStep as vo, spacingEqual as vp, SharedElementArgs as vr, clearMatchRanges as vs, ImageCommand as vt, LazySheet as vu, linkHoverOf as w, parseColor as w_, withOverrideSource as wa, resolvePaintState as wc, gradientPaint as wd, UiDensity as wf, TextMeasureRequest as wg, hasDecorationPhase as wh, interactive as wi, BoxModelProps as wl, UiInputEvent as wm, Canvas2DRenderer as wn, UiKeyboardController as wo, insetsEqual as wp, iconSource as wr, UiEnvironmentProvider as ws, RenderTextCache as wt, SheetViewport as wu, textRunOfRecordId as x, colorValuesEqual as x_, formatConstraints as xa, isPaintVisible as xc, UiGradientStop as xd, highContrastColors as xf, SpannedRuns as xg, DecorationStroke as xh, BUTTON_INTERACTION as xi, ChildrenBindingId as xl, UiEventType as xm, LayoutInspector as xn, parseShortcut as xo, UiInsetRegistry as xp, IconSourceArgs as xr, FindMatch as xs, PrimitiveKind as xt, SheetRange as xu, semanticsInertAbove as y, colorToHex as y_, describeLength as ya, computeObjectFitRect as yc, UiGradient as yd, UiContrast as yf, ParagraphLayout as yg, DecorationRect as yh, decorated as yi, UiGraph as yl, UiBeforeInputEvent as ym, INSPECTOR_HEAT_MS as yn, describeShortcut as yo, spacingSteps as yp, motion as yr, matchRangesOf as ys, NO_CLIP_INDEX as yt, LazySheetProps as yu, markInstant as z, isNodeTabStop as za, lineLimit as zc, isMinMaxTrack as zd, shadowsOf as zf, UiTransitionSpec as zg, UiPointerEvents as zh, propertyEffects as zi, PaintProps as zl, MOTION_CHANNELS as zm, CanvasSurface as zn, NodeTransitions as zo, comparePositions as zp, parseSvg as zr, EditCommand as zs, initializeWebGPU as zt, VirtualUpdate as zu };
-//# sourceMappingURL=index-B5r1ETCh.d.ts.map
+export { Mp4AudioTrack as $, linear as $_, UiPlatformAdapter as $a, nextGraphemeEnd as $c, UiPropertyDefinition as $d, isTypographyRole as $f, UiTransitionSpec as $g, validateSubgrid as $h, placeGridItems as $i, TextProps as $l, MotionTiming as $m, InsetPaddingArgs as $n, UiFindController as $o, UiModifierLayout as $p, shortcut as $r, SpanPaint as $s, registerFontStack as $t, UiLayoutChild as $u, offsetAtPointIn as A, interpolateNumber as A_, withOverrideSource as Aa, resolvePaintState as Ac, UiLinearGradient as Ad, raiseContrast as Af, TextOverflow as Ag, UI_SUBGRID_AXES as Ah, interactive as Ai, BoxModelProps as Al, UiEventType as Am, traceRoundedRect as An, UiKeyboardController as Ao, UiInsetRegistry as Ap, mediaLoadsInFlight as Ar, UiEnvironmentProvider as As, createTextCache as At, SheetSourceArgs as Au, markNow as B, UiColor as B_, UiTimerFrameClockOptions as Ba, PlacedLine as Bc, PercentLength as Bd, UiShadowName as Bf, Size as Bg, UiObjectFit as Bh, closestPropertyName as Bi, GridItemProps as Bl, UiPointerKind as Bm, drawOverlayShapes as Bn, GestureRecognizerOptions as Bo, unknownContainerSize as Bp, isSvgSource as Br, isEditableNode as Bs, isWebGPUAvailable as Bt, LazySourceArgs as Bu, hasTextLinks as C, defaultMotion as C_, RelayoutExplanation as Ca, VerticalAlign as Cc, GradientPaint as Cd, themeExtension as Cf, ParagraphLayout as Cg, DecorationRect as Ch, decorated as Ci, BindingId as Cl, UiEventListener as Cm, INSPECTOR_HEAT_MS as Cn, UiShortcutRegistry as Co, textStylesEqual as Cp, motion as Cr, TEXT_MATCHES_PROP as Cs, RenderList as Ct, EditUnit as Cu, setLinkHover as D, springIn as D_, formatConstraints as Da, isPaintVisible as Dc, UiGradient as Dd, UiContrast as Df, TextLineRun as Dg, decorationRect as Dh, ShownAsKey as Di, ChildrenBindingId as Dl, MOUSE_POINTER as Dm, CanvasTextMeasurer as Dn, parseShortcut as Do, spacingEqual as Dp, ImageSources as Dr, FindMatch as Ds, TEXTURED_STRIDE_FLOATS as Dt, SheetHeaderRenderer as Du, linkRunAtPointIn as E, easingIn as E_, describeOverrides as Ea, createPaintState as Ec, ResolvedGradientStop as Ed, HighContrastOptions as Ef, TextLine as Eg, decorationColor as Eh, InteractiveOptions as Ei, UiEventBinding as El, UiListenerErrorReporter as Em, LayoutInspectorOptions as En, formatShortcut as Eo, scaleSpacing as Ep, ImageSourceArgs as Er, setMatchRanges as Es, TEXTURED_STRIDE_BYTES as Et, LazySheetProps as Eu, UiFrameCallback as F, parseTransform as F_, UiFrameTime as Fa, selectableTextNodes as Fc, radialGradient as Fd, defaultShadows as Ff, spannedRunsFor as Fg, UiCursor as Fh, bundle as Fi, ContainerProps as Fl, UiKeyboardEvent as Fm, LayoutReader as Fn, UiScrollBehavior as Fo, observeViewportInsets as Fp, IconSpec as Fr, CARET_WIDTH as Fs, GlyphSlot as Ft, sheetSource as Fu, VttTrack as G, normalizeColor as G_, isNodeTabStop as Ga, lineLimit as Gc, isAutoLength as Gd, boxShadowValuesEqual as Gf, UiEnvironment as Gg, UiSelfAlignment as Gh, propertyEffects as Gi, PaintProps as Gl, noKeyModifiers as Gm, resolveBoolean as Gn, NodeTransitions as Go, UiGroupEdit as Gp, DefaultImageResolverOptions as Gr, EditCommand as Gs, WebGPURenderer as Gt, VirtualItemMeasure as Gu, performanceMarksEnabled as H, colorToRgba as H_, isNodeHitTestable as Ha, caretRectFor as Hc, UiTrackSize as Hd, boxShadowArraysEqual as Hf, clampSize as Hg, UiPlacement as Hh, getPropertyNames as Hi, IdentityProps as Hl, UiTextChangeEvent as Hm, CanvasHost as Hn, PinchRecognizerOptions as Ho, UiTextInputState as Hp, SvgRect as Hr, isReadOnly as Hs, CapturedFrame as Ht, VIRTUAL_INDEX_PROP as Hu, UiScheduler as I, transform as I_, UiHostFrameClock as Ia, selectableTextOf as Ic, validateGradient as Id, shadowsEqual as If, Constraints as Ig, UiDirection as Ih, noModifiers as Ii, EditableTextProps as Il, UiPasteEvent as Im, RenderChanges as In, UiScrollability as Io, UiContainerSize as Ip, iconKey as Ir, EDITOR_PROP as Is, GlyphUpload as It, LazyAxis as Iu, ByteSource as J, rgba as J_, resolveCursor as Ja, offsetForVerticalMove as Jc, isPercentLength as Jd, shadowsOf as Jf, createEnvironmentKey as Jg, UiTextDirection as Jh, propertyValuesEqualByName as Ji, Reactive as Jl, MOTION_CHANNELS as Jm, resolvePropertyByName as Jn, overrideSources as Jo, comparePositions as Jp, animateLayout as Jr, detectEditingPlatform as Js, WebGPUSurface as Jt, lazySource as Ju, cueAt as K, parseColor as K_, isSubtreeInert as Ka, offsetAtPoint as Kc, isFrLength as Kd, boxShadowsEqual as Kf, UiEnvironmentKey as Kg, UiSubgridAxis as Kh, propertyIsInherited as Ki, PositionProps as Kl, wheelDeltaYOf as Km, resolveNumber as Kn, resetTransitionWarnings as Ko, UiTextPosition as Kp, ImageResolver as Kr, EditingPlatform as Ks, WebGPURendererOptions as Kt, VirtualUpdate as Ku, UiSchedulerOptions as L, transformIsIdentity as L_, UiHostFrameClockOptions as La, selectionRangeOf as Lc, AutoLength as Ld, BOX_SHADOW_BLUR_REACH as Lf, LayoutBox as Lg, UiFlexWrap as Lh, Transform as Li, EnvironmentProps as Ll, UiPinchEvent as Lm, RenderContext as Ln, UiWheelController as Lo, UiContainerSizeSource as Lp, DefaultSvgResolver as Lr, caretVisibleAt as Ls, WebGPUGlyphAtlas as Lt, LazyGridOptions as Lu, paragraphGeometryFrom as M, interpolatorFor as M_, UiAnimationFrameClock as Ma, TEXT_SELECTION_PROP as Mc, gradientPaint as Md, UiDensity as Mf, TextRunSpan as Mg, UiBorderRadiusValue as Mh, measureFlow as Mi, ButtonProps as Ml, UiGestureEvent as Mm, ScrollLayerStats as Mn, UiPointerController as Mo, UiInsets as Mp, IconContext as Mr, UiEnvironmentKeys as Ms, textRuns as Mt, UiVirtualSheet as Mu, selectionRectsIn as N, UiTransform as N_, UiFrameClock as Na, TextRange as Nc, gradientsEqual as Nd, densityFactors as Nf, TextRunStyle as Ng, UiColorValue as Nh, pressable as Ni, ColumnProps as Nl, UiInputEvent as Nm, RendererBackend as Nn, ScrollContainerState as No, insetsEqual as Np, IconRasterizer as Nr, EnvironmentNotifier as Ns, GlyphShaper as Nt, UiVirtualSheetOptions as Nu, ParagraphGeometry as O, UiInterpolator as O_, formatExplanation as Oa, normalizeTextAlign as Oc, UiGradientOffset as Od, contrastRatio as Of, TextMeasureRequest as Og, hasDecorationPhase as Oh, UiShownAs as Oi, UiChildrenBinding as Ol, UiBeforeInputEvent as Om, Canvas2DRenderer as On, shortcutKeyCaps as Oo, spacingSteps as Op, iconSource as Or, FindOptions as Os, TextRunDraw as Ot, SheetRange as Ou, wordRangeIn as P, UiTransforms as P_, UiFrameClockFactory as Pa, clearSelectionRange as Pc, linearGradient as Pd, UiShadows as Pf, TextWrap as Pg, UiContentDistribution as Ph, UiModifierBundle as Pi, CommonProps as Pl, UiKeyModifiers as Pm, UiRenderer as Pn, ScrollSink as Po, noInsets as Pp, IconRasterizerOptions as Pr, CARET_BLINK_MS as Ps, GLYPH_SUBPIXEL_PHASES as Pt, VIRTUAL_SHEET_PROP as Pu, rangeSource as Q, easings as Q_, PlatformSurface as Qa, lineStartAt as Qc, resolveLength as Qd, defaultTypography as Qf, DirtyFlags as Qg, UiVerticalAlign as Qh, GridTrack as Qi, TextContentProps as Ql, MotionStateInput as Qm, sameArgs as Qn, FindHost as Qo, UiModifierFocus as Qp, contextMenu as Qr, PlacedTextRun as Qs, fontStackFor as Qt, MAX_MEASURES_PER_CHILD as Qu, MARK_PREFIX as R, transformsEqual as R_, UiManualFrameClock as Ra, setSelectionRange as Rc, FrLength as Rd, UiBoxShadow as Rf, LayoutResult as Rg, UiFontWeight as Rh, accumulatedOffsetTo as Ri, FlexContainerProps as Rl, UiPointerDevice as Rm, LABEL_PADDING_X as Rn, isScrollContainer as Ro, bandOf as Rp, DefaultSvgResolverOptions as Rr, editorFor as Rs, WebGPUTextureCache as Rt, LazyItemRenderer as Ru, clearLinkHover as S, UiSpringToken as S_, OverrideSources as Sa, TextAlign as Sc, UiImage as Sd, noThemeExtensions as Sf, FontMetrics as Sg, DecorationFill as Sh, borders as Si, UiDefinition as Sl, UiProps as Sm, svgPaint as Sn, UiShortcutBinding as So, textSpansEqual as Sp, SharedElementArgs as Sr, SubtreeBounds as Ss, RenderCommand as St, CompositionRange as Su, linkOf as T, durationIn as T_, describeLength as Ta, computeObjectFitRect as Tc, ResolvedGradient as Td, withThemeExtension as Tf, SpannedRuns as Tg, DecorationStroke as Th, BUTTON_INTERACTION as Ti, UiGraph as Tl, UiInputDispatcher as Tm, LayoutInspector as Tn, describeShortcut as To, defaultSpacing as Tp, IconSourceArgs as Tr, matchRangesOf as Ts, ScissorRect as Tt, LazySheet as Tu, setPerformanceMarks as U, colorValuesEqual as U_, isNodeInert as Ua, lineIndexAtY as Uc, auto as Ud, boxShadowRadius as Uf, constraintsEqual as Ug, UiPointerEvents as Uh, inheritedPropertyFlags as Ui, InteractionProps as Ul, UiWheelDeltaMode as Um, CanvasSurface as Un, UiPinchRecognizer as Uo, textInputOf as Up, parseSvg as Ur, nextCaretToggle as Us, DrawStats as Ut, VIRTUAL_LEAD_PROP as Uu, measureSpan as V, colorToHex as V_, isNodeFocusable as Va, RunMeasure as Vc, UiLength as Vd, boxShadow as Vf, TightenOptions as Vg, UiOverflow as Vh, findPropertyDefinition as Vi, GridProps as Vl, UiSelectionChangeEvent as Vm, labelOrigin as Vn, UiGestureRecognizer as Vo, UiTextInput as Vp, SvgDocument as Vr, isMultiline as Vs, WebGPUError as Vt, UiVirtualWindow as Vu, VttCue as W, colorsEqual as W_, isNodeSelectable as Wa, lineIndexForOffset as Wc, fr as Wd, boxShadowReach as Wf, tightenConstraints as Wg, UiPosition as Wh, inheritedPropertyNames as Wi, PaintElementProps as Wl, UiWheelEvent as Wm, createCanvasSurface as Wn, FocusNotifier as Wo, UiEditingGroup as Wp, DefaultImageResolver as Wr, syncEditorValue as Ws, RenderHooks as Wt, VIRTUAL_WINDOW_PROP as Wu, RangeSourceOptions as X, cubicBezier as X_, PlatformAdapterOptions as Xa, graphemeBoundaries as Xc, percent as Xd, UiTypographyExtensions as Xf, provided as Xg, UiTextWrapValue as Xh, GridItemRequest as Xi, ScrollViewProps as Xl, MotionChannel as Xm, ThemeTokenTarget as Xn, writeDeclaredProperty as Xo, editingGroupOf as Xp, ShortcutOptions as Xr, EditableLayout as Xs, bumpFontStack as Xt, isVideoSurface as Xu, DEFAULT_BLOCK_SIZE as Y, UiEasing as Y_, CanvasPlatformSurface as Ya, selectionRects as Yc, minmax as Yd, UiTypography as Yf, findEnvironmentKey as Yg, UiTextOverflowValue as Yh, GridContribution as Yi, RowProps as Yl, MOTION_REST as Ym, resolveString as Yn, resetOverrideWarnings as Yo, edgeField as Yp, ContextMenuOptions as Yr, isPrintable as Ys, createWebGPUSurface as Yt, UiVideoSurface as Yu, bufferSource as Z, easingCss as Z_, PlatformEventTarget as Za, lineEndAt as Zc, repeat as Zd, UiTypographyRole as Zf, UiNodeType as Zg, UiThemeColorName as Zh, GridPlacement as Zi, StackProps as Zl, MotionState as Zm, themeTokens as Zn, writeOverrideProperty as Zo, UiModifierEnvironment as Zp, ShortcutsOptions as Zr, CanvasTextStyle as Zs, clearFontStacks as Zt, videoFrameSize as Zu, buildSemanticsTree as _, UiEasingToken as __, AxisExplanation as _a, DEFAULT_TEXT_COLOR as _c, UiPaint as _d, UiThemeExtension as _f, darkColors as _g, NodeProperty as _h, BorderEdge as _i, Row as _l, isComponentLikeElement as _m, PaintRecording as _n, UiDroppedFile as _o, resolvedSpansOf as _p, RangeResponse as _r, scrollRange as _s, INSTANCE_STRIDE_FLOATS as _t, isUiSemanticState as _u, diffSemantics as a, AnimatedCell as a_, parseCrossAxisAlignment as aa, drawText as ac, defaultVisualState as ad, withPointer as af, borderRadiusIsZero as ag, rotateFrom as ah, DragSourceOptions as ai, ResponsiveProps as al, defineModifier as am, PaintContext2D as an, EditingControllerOptions as ao, UiResolvedTextSpan as ap, breakpoint as ar, HitTester as as, Mp3Frame as at, UiPropertyName as au, semanticsMemory as b, UiSpringExtensions as b_, LayoutExplanation as ba, PaintState as bc, paintValuesEqual as bd, defineThemeExtension as bf, CharacterCountTextMeasurer as bg, UiPropertyOverride as bh, FocusRingOptions as bi, Text as bl, isUiElement as bm, SvgFit as bn, ShortcutRegistryOptions as bo, spansDifferOnlyInPaint as bp, canDecodeVideo as br, scrollbarZoneAt as bs, PrimitiveCommand as bt, validateRole as bu, SemanticsMemory as c, UiReducedMotionPolicy as c_, parseFlexDirection as ca, runCanvasStyleInto as cc, visualStatesEqual as cd, lightTheme as cf, uniformBorderRadius as cg, slideFrom as ch, dragSource as ci, LazyGridProps as cl, UiModifierTeardown as cm, PaintLayers as cn, UiEditingController as co, UiTextLink as cp, ScrollPositionArgs as cr, SCROLLBAR_HOVER_ZONE as cs, readMp3Header as ct, UI_ROLES as cu, SemanticsRewalk as d, UiTween as d_, proportionalFontMetrics as da, textRunDecorations as dc, PaintLineCap as dd, withDensity as df, UiShapes as dg, UiSharedElements as dh, DragOffset as di, Box as dl, UiFocusManager as dm, PaintResolver as dn, EXTERNAL_FILES as do, UiTextSpan as dp, VideoSourceArgs as dr, SCROLLBAR_THICKNESS as ds, Affine as dt, UiLiveRegion as du, UiTransitionValue as e_, sizeGridTracks as ea, TextLinePlacement as ec, UiLayoutContext as ed, defineProperty as ef, UiBorderRadius as eg, ResolvedMotionState as eh, shortcuts as ei, nextWordEnd as el, UiModifierSet as em, PaintPictureCache as en, capturePointer as eo, typographyEqual as ep, PublishInsetArgs as er, SelectionControllerOptions as es, Mp4Sample as et, TypographyProps as eu, steps as ev, SemanticsSpan as f, UiTweenOptions as f_, LayoutNotifier as fa, Canvas2DContext as fc, PaintLineJoin as fd, UiLengths as ff, defaultShapes as fg, AnimationDriver as fh, DraggableOptions as fi, Button as fl, ComponentResolver as fm, PaintTarget as fn, UiDragPayload as fo, UiTextStyle as fp, VideoState as fr, ScrollBounds as fs, CLIP_STRIDE_BYTES as ft, UiOrientation as fu, buildSemanticsSubtree as g, UiEasingExtensions as g_, ScrollAdjustment as ga, DEFAULT_FONT_WEIGHT as gc, PaintTextStyle as gd, unitsEqual as gf, colorsEqualPalette as gg, NodeId as gh, autoFocus as gi, Paint as gl, UiSourceLocation as gm, PaintRecorder as gn, UiDropZone as go, hiddenRangesOf as gp, DefaultVideoResolverOptions as gr, scrollLeaderOf as gs, INSTANCE_STRIDE_BYTES as gt, isUiRole as gu, UiSemanticsRecord as h, UiDurationToken as h_, SCROLLBAR_LINGER_MS as ha, DEFAULT_FONT_SIZE as hc, PaintTextAlign as hd, lengths as hf, UiColors as hg, motionOf as hh, clickOutside as hi, Grid as hl, UiElement as hm, PaintOp as hn, UiDropEffect as ho, flattenTextSpans as hp, DefaultVideoResolver as hr, scrollBounds as hs, GlyphCommand as ht, UiSemanticStates as hu, UiSemanticsPatch as i, tween as i_, parseAlignContent as ia, createCanvasTextStyle as ic, UiVisualStateSet as id, UiThemeTouch as if, borderRadiusEqual as ig, resolveMotionState as ih, AutoScrollOptions as ii, Responsive as il, UiModifierKind as im, PaintCanvasFactory as in, touchActionFor as io, UiFontVariant as ip, SizeContainerArgs as ir, HitTestResult as is, Mp3Format as it, UiProperties as iu, paragraphGeometry as j, interpolateTransform as j_, UiFrame as ja, DEFAULT_LINE_HEIGHT_FACTOR as jc, UiRadialGradient as jd, relativeLuminance as jf, TextRunMeasurer as jg, UiAlignment as jh, measure as ji, BoxProps as jl, UiFocusEvent as jm, LayerCanvasFactory as jn, PointerControllerOptions as jo, UiInsetSource as jp, IconCanvas as jr, provideEnvironment as js, glyphCount as jt, SheetViewport as ju, hasDrawnText as k, interpolateColor as k_, labelNode as ka, normalizeVerticalAlign as kc, UiGradientStop as kd, highContrastColors as kf, TextMeasurer as kg, paintsAfterChildren as kh, hoverable as ki, UiGraphBuilder as kl, UiCompositionEvent as km, Canvas2DRendererOptions as kn, KeyboardControllerOptions as ko, UiInsetEdge as kp, imageSource as kr, findMatchesIn as ks, buildRenderList as kt, SheetRowRenderer as ku, SemanticsPlacement as l, UiSpring as l_, ELLIPSIS as la, runFontString as lc, PaintBox as ld, themesEqual as lf, UiShapeExtensions as lg, slideUp as lh, dropTarget as li, LazyListProps as ll, FocusOptions as lm, PaintMatrix as ln, TouchScrollerOptions as lo, UiTextMetrics as lp, scrollPosition as lr, SCROLLBAR_INSET as ls, splitMp3Frames as lt, UI_SEMANTIC_STATES as lu, UiSemanticsMap as m, UiDurationExtensions as m_, SCROLLBAR_FADE_MS as ma, DEFAULT_FONT_FAMILY as mc, PaintSurface as md, defaultUnits as mf, shapesEqual as mg, clockOf as mh, ClickOutsideOptions as mi, EditableText as ml, UiChild as mm, EMPTY_RECORDING as mn, UiDragState as mo, editableSpansOf as mp, videoSource as mr, ScrollbarThumb as ms, CommandKind as mt, UiSemanticState as mu, UiSemanticsBox as n, normalizeTransition as n_, CrossAxisAlignment as na, applyCanvasTextStyle as nc, isLayoutProtocol as nd, TOUCH_TARGET as nf, borderRadius as ng, isMotionRest as nh, ZoomState as ni, previousWordStart as nl, assertModifierList as nm, paintPictures as nn, pointerDeviceOf as no, UiFontStretch as np, publishInset as nr, UiSelectionController as ns, demuxMp4Audio as nt, UiNodeRef as nu, dropIndexShifts as o, UiAnimation as o_, parseMainAxisAlignment as oa, fillTextRects as oc, hasVisualState as od, UiTheme as of, borderRadiusValuesEqual as og, scaleFrom as oh, DropTargetOptions as oi, LazyColumn as ol, isUiModifier as om, PaintDeviceRect as on, EditingHost as oo, UiSpannedText as op, sizeContainer as or, UiHitTester as os, Mp3Frames as ot, UiPropertyValueOf as ou, TEXT_RUN_ID_SEPARATOR as p, createTween as p_, LayoutEngine as pa, Canvas2DGradient as pc, PaintMaskMode as pd, UiUnits as pf, isShapeName as pg, UiClock as ph, draggable as pi, Column as pl, ComponentLikeElement as pm, tracePathData as pn, UiDragSession as po, defaultTextStyle as pp, VideoTransport as pr, ScrollbarAxis as ps, CLIP_STRIDE_FLOATS as pt, UiRole as pu, parseWebVtt as q, rgb8 as q_, pointerEventsOf as qa, offsetAtX as qc, isMinMaxTrack as qd, fittedShadowRadius as qf, UiProvision as qg, UiTextAlign as qh, propertyNarrowers as qi, PropsOf as ql, DirtyNodeSet as qm, resolveProperty as qn, clearOverrideProperty as qo, adjacentField as qp, AnimateLayoutOptions as qr, commandForKey as qs, WebGPUCanvasHost as qt, VirtualViewport as qu, UiSemanticsUpdate as r, spring as r_, MainAxisAlignment as ra, buildFontString as rc, UiVisualState as rd, UiPointer as rf, borderRadiusCorners as rg, pop as rh, pinchable as ri, wordRangeAt as rl, UiModifier as rm, PaintCanvas as rn, prepareInputSurface as ro, UiFontStyle as rp, BreakpointArgs as rr, HitTestLayoutReader as rs, demuxMp4Video as rt, UiHoldUnseen as ru, recordsEqual as s, UiAnimationOptions as s_, FlexDirection as sa, layoutTextLines as sc, visualState as sd, darkTheme as sf, normalizeBorderRadius as sg, slideDown as sh, ReorderableOptions as si, LazyGrid as sl, UiModifierHost as sm, PaintGradient as sn, EditingState as so, UiTextDecoration as sp, ScrollOffset as sr, UiPoint as ss, Mp3Header as st, UiPropertyValues as su, UiSemanticsAction as t, assertTransitionMap as t_, AlignContent as ta, TextRunRect as tc, UiLayoutProtocol as td, propertyValuesEqual as tf, UiBorderRadiuses as tg, fade as th, PinchableOptions as ti, previousGraphemeStart as tl, UiUnknownModifierPropertyError as tm, PaintStats as tn, isImeKey as to, UiFontKerning as tp, insetPadding as tr, SelectionHost as ts, Mp4VideoTrack as tt, UiEventProps as tu, SemanticsReuse as u, UiSpringOptions as u_, layoutParagraph as ua, textRunBackgrounds as uc, PaintFillRule as ud, withContrast as uf, UiShapeName as ug, SharedClaim as uh, reorderable as ui, LazyRow as ul, FocusSource as um, PaintPixels as un, UiTouchScroller as uo, UiTextRange as up, VideoClock as ur, SCROLLBAR_MIN_THUMB as us, WebGPUGlyphPages as ut, UiAutocomplete as uu, rewalkSemantics as v, UiMotion as v_, CustomLayoutExplanation as va, ObjectFit as vc, UiPath as vd, UiThemeExtensionOptions as vf, lightColors as vg, UiNode as vh, BordersOptions as vi, ScrollView as vl, isObservable$1 as vm, replayPaint as vn, UiFileDropMessage as vo, spanAtOffset as vp, VideoPlayback as vr, scrollbarThumb as vs, ImageCommand as vt, normalizeStates as vu, linkHoverOf as w, defineMotion as w_, SizeDecision as wa, colorToCss as wc, MAX_GRADIENT_STOPS as wd, themeExtensionsEqual as wf, ParagraphTextMeasurer as wg, DecorationShape as wh, focusRing as wi, UiBinding as wl, UiEventListenerOptions as wm, InspectorOverlay as wn, UiShortcutStep as wo, UiSpacing as wp, sharedElement as wr, clearMatchRanges as ws, RenderTextCache as wt, EditableTextModel as wu, textRunOfRecordId as x, UiSpringSpec as x_, LayoutStateExplanation as xa, PaintTextSpan as xc, pathValuesEqual as xd, hasThemeExtension as xf, FixedMetricsOptions as xg, UiPropertyOverrides as xh, borderShapes as xi, createElement as xl, UiPropValue as xm, drawSvg as xn, UiShortcut as xo, textContentOf as xp, MotionArgs as xr, scrollsFromRight as xs, PrimitiveKind as xt, validateStates as xu, semanticsInertAbove as y, UiMotionChanges as y_, Edges as ya, PaintBoxShadow as yc, inputsEqual as yd, UiThemeExtensions as yf, LayoutRecord as yg, UiNodeTransitions as yh, Decorations as yi, Stack as yl, isUiChild as ym, SvgDrawOptions as yn, dragSessionFor as yo, spannedTextOf as yp, VideoResolver as yr, scrollbarThumbs as ys, NO_CLIP_INDEX as yt, statesEqual as yu, markInstant as z, UiBasicColors as z_, UiTimerFrameClock as za, CaretRect as zc, MinMaxTrack as zd, UiBoxShadows as zf, LayoutStats as zg, UiGridAutoFlow as zh, contentOffset as zi, FlexItemProps as zl, UiPointerEvent as zm, OverlayShape as zn, GestureInput as zo, containerBands as zp, SvgResolver as zr, editorOf as zs, initializeWebGPU as zt, LazyListOptions as zu };
+//# sourceMappingURL=index-BSoAnZP0.d.ts.map