gesso-core 0.1.0 → 0.2.0

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

@@ -410,7 +410,29 @@ declare abstract class UiAnimation<T> {
   protected startedAt: number;
   private begun;
   private readonly subject;
-  private lastSampledAt;
+  /**
+   * When this animation next *wants* a sample, on the ideal timeline.
+   *
+   * The ideal one, and that word is carrying the whole fix. This used
+   * to be derived at the point of asking, as `lastSampledAt + stepMs`,
+   * which sounds equivalent and is not: frames arrive on the display's
+   * refreshes, so a sample is nearly always served a little after it
+   * was due, and measuring the next step from when it was *served*
+   * rounds the period up to a whole refresh and keeps the rounding.
+   *
+   * The arithmetic is unforgiving. A 24fps clip wants 41.67ms; on a
+   * 60Hz display the refresh at 33.3ms is too early and the one at
+   * 50ms serves it, so the next step is measured from 50, wants 91.67,
+   * and is served at 100. The period is not 41.67ms but 50ms, which is
+   * 20fps: one frame in six dropped, for ever, on the commonest clip
+   * rate there is. Measured, not reasoned about; see the spec beside
+   * this file.
+   *
+   * Advancing the ideal time by exactly `stepMs` instead lets the
+   * served times alternate between 33.3 and 50 and average out to the
+   * rate that was asked for.
+   */
+  private nextDueAt;
   private lastWritten;
   private finished;
   protected constructor(cell: AnimatedCell<T>, stepMs: number, reducedMotionPolicy: UiReducedMotionPolicy, delayMs?: number);
@@ -459,6 +481,18 @@ declare abstract class UiAnimation<T> {
   get hasBegun(): boolean;
   protected onBegin(): void;
   advance(now: number): void;
+  /**
+   * Moves the ideal timeline on by one step.
+   *
+   * Resynchronised rather than caught up when a whole step has already
+   * gone by: that means the application stalled, or the tab was
+   * hidden, and the samples that were missed are not worth taking now.
+   * For a video they are frames already past, and presenting is a pure
+   * function of a position, so chasing the backlog would sample
+   * several times in a row to arrive exactly where a single sample
+   * arrives anyway.
+   */
+  private scheduleNext;
   /** Writes the target and completes, for reduced motion and for `duration: 0`. */
   snap(): void;
   /** Stops without reaching the target: superseded, or the node left. */
@@ -2600,6 +2634,28 @@ interface UiModifierHost {
    * list behind the scroll.
    */
   flowBox(): LayoutBox | null;
+  /**
+   * The whole surface the application is drawn on, in the same
+   * coordinates `layoutBox` answers in.
+   *
+   * Here so that a modifier can tell whether its node is somewhere a
+   * reader could see it, which is a question only the expensive
+   * modifiers ask and the reason this is in the budget at all: a
+   * decoder, a poller or anything else that costs whether or not it is
+   * looked at has no business running for a node scrolled a thousand
+   * pixels off the bottom. `videoSource` is the case that earned it —
+   * a page of clips used to cost the sum of all of them however few
+   * were on screen.
+   *
+   * It is the *root's* box and not the window's, so it is right for an
+   * application that does not fill its page and correct under the same
+   * scrolling `layoutBox` already accounts for. Null wherever
+   * `layoutBox` is: before the first layout, and in a headless graph
+   * with no layout at all — and a modifier that gets null must carry
+   * on as though the node were visible, because "no measurement yet"
+   * and "off screen" are not the same answer.
+   */
+  viewportBox(): LayoutBox | null;
   /**
    * How far this node is scrolled, or null for one that is not a
    * scroll container.
@@ -2776,6 +2832,16 @@ interface UiModifierLayout {
     x: number;
     y: number;
   } | null;
+  /**
+   * The drawn surface, in the same coordinates `box` answers in; see
+   * `UiModifierHost.viewportBox`.
+   *
+   * Optional, and absent means unknown. A layout double in a spec, and
+   * a headless graph, have no surface to report — and a modifier that
+   * gets null must carry on as though its node were visible, because
+   * "nobody is drawing" and "off screen" are not the same answer.
+   */
+  viewport?(): LayoutBox | null;
   onLayout(node: UiNode, listener: (box: LayoutBox) => void): () => void;
 }
 /**
@@ -10206,6 +10272,16 @@ interface UiTimerFrameClockOptions {
   now?: () => UiFrameTime;
 }
 interface UiHostFrameClockOptions {
+  /**
+   * This thread's own `requestAnimationFrame`, where it has one.
+   *
+   * Defaults to looking for it, which is the whole point: a dedicated
+   * worker has one, and using it removes the host from the frame path
+   * entirely. Pass `null` to force the hosted path, which specs do and
+   * which is also the escape hatch if a browser's worker frames ever
+   * turn out to be worse than its host's.
+   */
+  requestAnimationFrame?: ((callback: (time: number) => void) => number) | null;
   /** How long to wait for a host tick before pacing a frame anyway. */
   fallbackMs?: number;
   /**
@@ -10243,33 +10319,6 @@ declare class UiTimerFrameClock implements UiFrameClock {
   requestFrame(): void;
   cancelFrame(): void;
 }
-/**
- * A clock whose frames arrive from somewhere else.
- *
- * The one thing a worker cannot do for itself. `requestAnimationFrame`
- * is tied to the compositor and exists only on the main thread, so a
- * render worker's frames were paced by `UiTimerFrameClock` at a fixed
- * 16ms — roughly sixty a second on any display, aligned to none of
- * them. On a 165Hz monitor that is not merely slower than it could be:
- * an unaligned timer lands two frames inside one refresh, or none, so
- * the pacing is uneven as well as capped.
- *
- * This clock does no timing at all. It reports when it wants frames
- * and delivers whatever ticks it is handed, which lets the shell —
- * the one thread with a `requestAnimationFrame` — supply the display's
- * own cadence. That is the narrow exception to keeping the shell
- * uninvolved: not work moved back onto the main thread for
- * convenience, but the single fact a worker has no way to observe.
- *
- * **Ticks are free-running while frames are wanted, not requested one
- * at a time.** A tick per request would cost a round trip inside every
- * frame: if the request reaches the shell after that vsync's callback
- * has run, the tick waits for the next one and the rate halves. So
- * `onActive(true)` means "keep ticking" and `onActive(false)` means
- * "stop"; a tick arriving with nothing pending is dropped, which costs
- * one comparison and makes the timing robust to whichever side is
- * late.
- */
 declare class UiHostFrameClock implements UiFrameClock {
   private readonly onFrame;
   /** Told when this starts and stops wanting ticks. */
@@ -10309,9 +10358,14 @@ declare class UiHostFrameClock implements UiFrameClock {
   private readonly stallMs;
   private readonly minStallMs;
   private readonly now;
+  /** This thread's own `requestAnimationFrame`, or null where there is none. */
+  private readonly local;
+  private localHandle;
   constructor(onFrame: (time: UiFrameTime) => void,
   /** Told when this starts and stops wanting ticks. */
   onActive: (active: boolean) => void, options?: UiHostFrameClockOptions);
+  /** Whether this clock is driving itself from the compositor. */
+  get isLocal(): boolean;
   requestFrame(): void;
   /**
    * Arms the timer that draws a frame the host did not ask for.
@@ -12872,8 +12926,47 @@ interface VideoPlayback {
    * zero is what looping is.
    */
   present(positionMs: number): boolean;
+  /**
+   * Whether the decoder is still working towards the position it was
+   * last given.
+   *
+   * A seek lands on the sync sample *before* where it was aimed, and
+   * everything between the two has to be decoded and thrown away
+   * before the wanted picture exists. On a two-second GOP that is a
+   * handful of frames and invisible; on a long one it is long enough
+   * that an interface wanting to say so — a scrubber that dims, a
+   * spinner over the poster — needs to be told. False while playing
+   * forwards, because then every decoded frame is one that will be
+   * shown.
+   *
+   * Optional, and absent means false. A playback that produces its
+   * pictures on demand — the generated ones the documentation is built
+   * on, a canvas, a stream of bitmaps — never waits for a keyframe it
+   * has no concept of, and should not have to say so.
+   */
+  readonly seeking?: boolean;
   /** Called when the video fails, with what went wrong. */
   onError(listener: (error: unknown) => void): () => void;
+  /**
+   * Called when a decoded frame arrived and changed the picture
+   * without anyone having asked for it.
+   *
+   * Which sounds like a contradiction of everything `present` says
+   * about who owns time, and is not: the position is still driven from
+   * outside, and this fires only for a position that has *already*
+   * been asked for and could not be answered yet. A seek is the case.
+   * `present(3.5s)` resets the decoder and returns with nothing to
+   * show, because the frame for 3.5s will not exist for another few
+   * milliseconds; when it lands, the driver is not going to call again
+   * — a paused clip has no next frame — so the picture would stay on
+   * whatever was there before the seek, forever.
+   *
+   * So the playback presents it and says so, and a caller repaints.
+   * Optional for the same reason `seeking` is: a playback that
+   * produces its pictures on demand answers every `present` on the
+   * spot and has nothing to announce.
+   */
+  onFrame?(listener: () => void): () => void;
 }
 /**
  * Turns a source into something a renderer can draw, frame by frame.
@@ -12893,11 +12986,37 @@ interface VideoResolver {
   release(source: string): void;
   dispose(): void;
 }
+/** Part of a file, and how long the whole of it is. */
+interface RangeResponse {
+  readonly data: ArrayBuffer;
+  /**
+   * The file's total length in bytes.
+   *
+   * Asked for alongside the bytes because an HTTP range response
+   * already carries it, in `Content-Range`, and a separate `HEAD`
+   * request to learn the same thing is a round trip for nothing.
+   */
+  readonly total: number;
+}
 interface DefaultVideoResolverOptions {
   /** How many finished playbacks to keep after their last holder let go. */
   capacity?: number;
   /** Injectable for specs, and for an app that fetches through its own stack. */
   fetch?: (source: string) => Promise<ArrayBuffer>;
+  /**
+   * Fetches `[start, end)` of a file, for playing one without holding
+   * all of it.
+   *
+   * Given this, the resolver finds the `moov` with a few small
+   * requests and then reads media as the decoder asks for it, which is
+   * what makes an hour of video possible; given only `fetch`, it reads
+   * the whole file at once, which is right for the looping clips this
+   * framework is usually asked for and is what it has always done.
+   * Neither is a default the other should be silently upgraded to — a
+   * ranged read of a two megabyte loop is three round trips where one
+   * would do — so an application says which it wants.
+   */
+  fetchRange?: (source: string, start: number, end: number) => Promise<RangeResponse>;
 }
 /** Whether this thread can decode video at all. */
 declare function canDecodeVideo(): boolean;
@@ -12916,6 +13035,7 @@ declare class DefaultVideoResolver implements VideoResolver {
   private readonly evictable;
   private readonly capacity;
   private readonly fetchBuffer;
+  private readonly fetchRange;
   private disposed;
   constructor(options?: DefaultVideoResolverOptions);
   /** Live or in-flight sources, for specs and the inspector. */
@@ -12924,9 +13044,141 @@ declare class DefaultVideoResolver implements VideoResolver {
   release(source: string): void;
   dispose(): void;
   private open;
+  private openWhole;
+  /**
+   * Finds the `moov`, reads it, and leaves the media where it is.
+   *
+   * The top-level structure of an MP4 is a flat list of boxes, each of
+   * which states its own length, so the whole of it can be walked by
+   * reading eight bytes at a time and jumping — which means finding
+   * the `moov` costs a couple of small requests whether it is at the
+   * front of the file (`-movflags +faststart`, and every file served
+   * for streaming) or at the back (the default, and every file written
+   * by a camera).
+   *
+   * The `moov` is then demuxed *on its own*, which works because the
+   * offsets in a sample table are absolute positions in the file
+   * rather than relative to anything: the tables are as correct read
+   * out of a two hundred kilobyte buffer as out of a gigabyte one.
+   */
+  private openRanged;
 }
 //#endregion
 //#region src/modifiers/video.d.ts
+/**
+ * Where a clip stands: loading it, showing it, or having failed.
+ *
+ * `playing` is about the *picture*, not about motion — it is the
+ * moment a surface reaches the node, and it arrives for a clip built
+ * with `autoplay: false` exactly as it does for one that runs. Whether
+ * time is moving is `VideoTransport.paused`, which is a different
+ * question and was never what this answered.
+ */
+type VideoState = 'loading' | 'playing' | 'failed';
+/**
+ * The clock a video's position comes from, when it is not the video's
+ * own.
+ *
+ * The default is a tween on the animation driver, which is right for
+ * a clip with no sound: nothing else in the application has an opinion
+ * about where the clip should be, so the frame clock may as well
+ * decide.
+ *
+ * It stops being right the moment there is audio. Audio cannot drop
+ * samples the way video drops frames — a gap is audible and a
+ * resample is worse — so where the two must agree, the audio is the
+ * clock and the picture follows it. That inversion is the whole reason
+ * this seam exists, and it is a *seam* rather than an implementation
+ * because `AudioContext` does not exist on a worker: the sound is
+ * played by the shell, and what crosses the thread boundary is this
+ * one number. See `AudioService`, which already reports it.
+ *
+ * `positionSeconds` is called once per presentation and must be cheap.
+ * Returning a position that goes backwards is a seek, exactly as it is
+ * for the tween.
+ */
+interface VideoClock {
+  /** Where the clip should be now, in seconds. */
+  positionSeconds(): number;
+  /** Whether the clock is running. A paused clock presents no new frames. */
+  readonly running: boolean;
+  /** Told when `running` changes, so the modifier can stop asking for frames. */
+  onChange(listener: () => void): () => void;
+}
+/**
+ * The handle on a running clip: where it is, and the four things that
+ * can be done to it.
+ *
+ * Handed out through `VideoSourceArgs.onReady` rather than returned,
+ * because a playback does not exist until a file has been fetched and
+ * a decoder configured, and a modifier attaches long before either.
+ *
+ * Nothing here is reactive. Core has no cells — `AnimatedCell` is an
+ * interface it asks others to satisfy, not a thing it implements — so
+ * this reports through `onChange` and the framework's tier wraps it in
+ * whatever its own state primitive is. `Video` does exactly that.
+ */
+interface VideoTransport {
+  /** The clip's length in seconds. Zero until the container has been read. */
+  readonly duration: number;
+  /** Where the picture is now, in seconds. */
+  readonly position: number;
+  /** Whether time has stopped. A seek while paused still moves the picture. */
+  readonly paused: boolean;
+  /** How fast time runs. 1 is the clip's own rate; 0.5 is half speed. */
+  readonly rate: number;
+  /**
+   * How loud, from 0 to 1, and whether it is silenced outright.
+   *
+   * **Nothing in this framework plays a clip's sound**, because
+   * `AudioContext` does not exist on the thread that decodes. So this
+   * is state rather than an effect: it is carried here, reported
+   * through `onVolume`, and it does something only where an
+   * application has wired that to whatever is actually making the
+   * noise — `AudioService`, on the shell. A control over it is honest
+   * for a clip whose sound is wired and a lie for one whose is not,
+   * which is why `Video` decides whether to draw one rather than
+   * always drawing it.
+   *
+   * `muted` is kept separate from a volume of zero, as every player
+   * keeps it: unmuting has to return to the level it was at, and a
+   * mute that wrote zero would have thrown that away.
+   */
+  readonly volume: number;
+  readonly muted: boolean;
+  /** Whether the decoder is still working towards the last position asked for. */
+  readonly seeking: boolean;
+  readonly state: VideoState;
+  play(): void;
+  pause(): void;
+  /** Moves to a position in seconds, clamped to the clip, playing or not. */
+  seek(seconds: number): void;
+  /** Positive, and clamped to something a decoder can keep up with. */
+  setRate(rate: number): void;
+  /** Clamped to 0..1. Setting it above zero also unmutes, as a slider dragged up should. */
+  setVolume(volume: number): void;
+  setMuted(muted: boolean): void;
+  /**
+   * Fetches, demuxes and configures again, for a clip that failed.
+   *
+   * The resolver caches by source, so a clip that failed *inside* the
+   * decoder is still held as a failed playback and this would resolve
+   * straight back to it. Releasing first is what makes the retry a
+   * real one.
+   */
+  retry(): void;
+  /**
+   * Told whenever any of the above changed, at most once a frame.
+   *
+   * Position is deliberately not part of that: it changes on every
+   * frame of every clip, and a listener woken sixty times a second to
+   * move a scrubber by a pixel is how a video costs an application its
+   * frame budget. Read `position` on the frames you are already
+   * drawing; this fires for the things that happen *to* a clip — it
+   * started, it stopped, it arrived somewhere, it broke.
+   */
+  onChange(listener: () => void): () => void;
+}
 interface VideoSourceArgs {
   readonly resolver: VideoResolver;
   readonly source: string;
@@ -12934,8 +13186,35 @@ interface VideoSourceArgs {
   readonly loop?: boolean;
   /** Start playing as soon as it is ready. Defaults to true. */
   readonly autoplay?: boolean;
+  /** How fast to play. Defaults to 1. */
+  readonly rate?: number;
+  /**
+   * Stop decoding while the node is off screen. Defaults to true.
+   *
+   * See `pauseWhenHidden` in this file for what "off screen" means and
+   * why the default is what it is.
+   */
+  readonly pauseWhenHidden?: boolean;
+  /** Where the position comes from, when it is not this clip's own tween. */
+  readonly clock?: VideoClock;
+  /** Starting volume, 0 to 1. Defaults to 1. */
+  readonly volume?: number;
+  readonly muted?: boolean;
+  /**
+   * Told when the volume or the mute changed, so an application can
+   * pass it to whatever is playing the sound. See `VideoTransport.volume`
+   * for why this is a report rather than an effect.
+   */
+  readonly onVolume?: (volume: number, muted: boolean) => void;
   /** Told when the video loads, starts or fails. */
-  readonly onState?: (state: 'loading' | 'playing' | 'failed', error?: unknown) => void;
+  readonly onState?: (state: VideoState, error?: unknown) => void;
+  /**
+   * Handed the transport once there is a playback to control.
+   *
+   * Called again after a successful `retry`, with a transport for the
+   * new playback; the old one is inert from the moment it was retried.
+   */
+  readonly onReady?: (transport: VideoTransport) => void;
 }
 /**
  * Plays a video onto the node's `video` property.
@@ -12949,20 +13228,29 @@ interface VideoSourceArgs {
  *
  * **Time comes from the animation driver, not from a timer.** The
  * playback is a pure function of a position, and the position is
- * driven by a repeating linear tween over the video's duration — an
- * ordinary animation on an ordinary cell. So a video is scheduled by
- * the same `ticks` phase as everything else, keeps its own frames
- * coming through the same `nextTickAt`, drops frames rather than
- * falling behind under load, and stops dead when the runtime does.
- * Nothing new had to be added to the runtime to play a video.
- *
- * **It keeps moving under reduced motion**, and that is deliberate.
- * The rule this framework applies (`UiReducedMotionPolicy`) is to stop
- * only when standing still would not state something false, and a
- * video that has frozen on its first frame is a video that has
- * finished loading badly. The media tier makes the same call for the
- * `Spinner`. An app that wants a still under reduced motion passes
- * `autoplay: false` and decides for itself.
+ * driven by a linear tween over the video's duration — an ordinary
+ * animation on an ordinary cell. So a video is scheduled by the same
+ * `ticks` phase as everything else, keeps its own frames coming
+ * through the same `nextTickAt`, drops frames rather than falling
+ * behind under load, and stops dead when the runtime does. Nothing new
+ * had to be added to the runtime to play a video.
+ *
+ * **Unless something else owns time.** A `clock` in the arguments
+ * replaces the tween, and is how a clip keeps step with sound that is
+ * being played somewhere this thread cannot reach. The rest of this
+ * file does not care which of the two it is driven by: both end at the
+ * same cell.
+ *
+ * **It keeps moving under reduced motion**, and that is deliberate for
+ * a clip with no transport. The rule this framework applies
+ * (`UiReducedMotionPolicy`) is to stop only when standing still would
+ * not state something false, and a video that has frozen on its first
+ * frame is a video that has finished loading badly. The media tier
+ * makes the same call for the `Spinner`. A clip the reader can *drive*
+ * is the other case — there the stillness is not a failure, it is a
+ * clip waiting to be played — so `Video` declines to autoplay under
+ * reduced motion when it has been given controls, and this modifier
+ * is told so through `autoplay`.
  *
  * **Playback is shared by source, not by node.** The resolver
  * reference-counts, so two nodes pointed at one file watch one
@@ -12984,10 +13272,14 @@ interface VideoSourceArgs {
  * The video appeared to freeze, the morph juddered, and when the old
  * screen finally left, the clip carried on from the beginning.
  *
- * So the position this node presents is its own tween plus whatever
- * the playback had already reached when it resolved. Both holders then
- * agree to within a frame, no seek fires, and the continuity this
- * comment claims is actually true.
+ * So a node starts its tween at whatever the playback had already
+ * reached, and the cell holds an absolute position in the clip rather
+ * than a distance from where this node joined. Both holders then agree
+ * to within a frame, no seek fires, and the continuity this comment
+ * claims is actually true. The earlier version of this kept a separate
+ * offset and wrapped the sum; holding the position outright is the
+ * same arithmetic with one fewer thing to get wrong, and it is what
+ * makes `seek` a single assignment.
  */
 declare const videoSource: ((args: VideoSourceArgs, key?: string | number) => UiModifier<VideoSourceArgs>) & {
   readonly kind: UiModifierKind<VideoSourceArgs>;
@@ -13519,6 +13811,26 @@ declare class Canvas2DRenderer implements UiRenderer {
   /** Scratch for the padded box text is drawn in; reused across nodes. */
   private readonly contentBox;
   private readonly paint;
+  /**
+   * Whose style the shared paint scratch currently holds.
+   *
+   * `resolvePaintState` folds about thirty properties — several of
+   * them inherited, so each is an ancestor walk — into one reused
+   * object. A node that paints text resolved twice: once for its own
+   * box, and again after the walk into its children, because a child
+   * overwrites the scratch before the text is drawn.
+   *
+   * Only the second one is conditional. A leaf never had a child to
+   * clobber it, and neither did a node whose children turned out to be
+   * every one of them invisible, culled or lifted — and leaves are
+   * most of the text in an application. Recording the owner answers
+   * "is the scratch still mine" exactly, for one reference compare,
+   * where asking `node.firstChild === null` would only approximate it
+   * and would go quietly wrong as the early-outs in `renderNode`
+   * change. Every write goes through `resolvePaint`, so the answer
+   * cannot drift from the truth.
+   */
+  private paintOwner;
   private cullX;
   private cullY;
   private cullWidth;
@@ -13547,6 +13859,11 @@ declare class Canvas2DRenderer implements UiRenderer {
   resize(width: number, height: number, dpr: number): void;
   dispose(): void;
   render(root: UiNode, context: RenderContext): void;
+  /**
+   * Folds a node's style into the shared scratch and records that it
+   * is now that node's. The one writer; see `paintOwner`.
+   */
+  private resolvePaint;
   private beginFrame;
   private renderNode;
   private renderChildren;
@@ -15311,15 +15628,16 @@ declare function splitMp3Frames(bytes: Uint8Array): {
  * `moov` and a `mdat`: `stsd` (with `avcC` or `hvcC`), `stts`, `ctts`,
  * `stsc`, `stsz`/`stz2`, `stco`/`co64` and `stss`. That is what every
  * encoder writes by default and what the `-movflags +faststart` files
- * on the web are.
+ * on the web are. Video tracks through `demuxMp4Video`, and audio
+ * tracks through `demuxMp4Audio` — which reads the same tables and
+ * differs only in which sample entry it understands.
  *
  * **What it does not.** Fragmented MP4 (`moof`/`traf`/`trun`), which
  * is what DASH and HLS segments are, and which is a different parse
  * rather than a harder one. It is detected and named rather than
  * mis-parsed into silence — a demuxer that returns zero samples for a
  * file the browser plays fine is a bug that takes an afternoon to
- * find. Audio is skipped entirely: there is nothing on this side of
- * the framework that could play it.
+ * find.
  *
  * **The whole file is parsed at once**, from one `ArrayBuffer`. Byte
  * ranges and progressive parsing are what you want for an hour of
@@ -15363,6 +15681,37 @@ interface Mp4VideoTrack {
    */
   readonly frameDurationUs: number;
 }
+/**
+ * The audio track of an MP4, as far as this reads it.
+ *
+ * Deliberately the same shape as `Mp4VideoTrack` where the two agree,
+ * because the sample tables they come out of are the same tables: only
+ * the sample *entry* differs, and only in which fields it carries.
+ *
+ * **Nothing in this framework plays it, and that is not this file's
+ * problem.** `AudioContext` does not exist on a worker, so sound is
+ * the shell's to play — see `VideoClock` for the arrangement and why
+ * it inverts which of the two owns time. What the demuxer is for here
+ * is the question that comes *before* that one: whether this clip has
+ * sound at all, and what it would take to decode it. A player that
+ * cannot answer that has to guess whether to show a mute button.
+ */
+interface Mp4AudioTrack {
+  /** A codec string for `AudioDecoder.configure`, e.g. `mp4a.40.2`. */
+  readonly codec: string;
+  readonly sampleRate: number;
+  readonly channels: number;
+  /** Bits per sample as the container declares them; 16 for nearly everything. */
+  readonly sampleSize: number;
+  /**
+   * The decoder configuration, where the codec keeps one out of band.
+   * For AAC this is the `AudioSpecificConfig` out of the `esds`, which
+   * `AudioDecoder` takes as its `description`.
+   */
+  readonly description?: Uint8Array;
+  readonly samples: readonly Mp4Sample[];
+  readonly durationUs: number;
+}
 /**
  * Reads the first video track out of an MP4.
  *
@@ -15372,6 +15721,210 @@ interface Mp4VideoTrack {
  * not understand this file", and those want different fixes.
  */
 declare function demuxMp4Video(data: ArrayBuffer): Mp4VideoTrack;
+/**
+ * Reads the first audio track out of an MP4.
+ *
+ * Null rather than a throw for a file that simply has no audio, which
+ * is the ordinary case for the clips this framework plays and is not
+ * an error in any sense. A file that *has* an audio track this cannot
+ * read still throws, for the reason `demuxMp4Video` gives: "no audio
+ * track" and "an audio track I do not understand" want different
+ * fixes.
+ */
+declare function demuxMp4Audio(data: ArrayBuffer): Mp4AudioTrack | null;
+//#endregion
+//#region src/media/ByteSource.d.ts
+/**
+ * Where a demuxed file's bytes come from.
+ *
+ * The seam that lets one `Mp4Playback` serve both of the things a
+ * video file can be. A fifteen-second loop is a few megabytes, is
+ * wanted in its entirety within a second of starting, and is simplest
+ * held in one `ArrayBuffer` — which is what this framework did, and
+ * still does by default. An hour of video is none of those things: it
+ * is a gigabyte, a viewer will watch four minutes of it, and holding
+ * it in memory to do so is not a trade-off but a mistake.
+ *
+ * Both are the same demux. A sample table names byte offsets into a
+ * file, and whether those bytes are already in memory or have to be
+ * asked for is a question about *transport*, not about the format. So
+ * the playback reads through this, and the two answers to that
+ * question are `bufferSource` and `rangeSource`.
+ *
+ * **`read` is synchronous and may answer null**, which is the whole
+ * design. The decoder is fed from inside a presentation, on the frame
+ * clock, and a `fill` that awaited anything would turn every frame
+ * into a microtask and every stall into a dropped frame. So `read`
+ * answers immediately or not at all, and a caller that gets null
+ * calls `request` and gets on with the frame it is in.
+ */
+interface ByteSource {
+  /** The whole file's length in bytes. */
+  readonly size: number;
+  /**
+   * The bytes at `offset`, if they are already here. Null means they
+   * are not, and says nothing about whether they ever will be.
+   */
+  read(offset: number, size: number): Uint8Array | null;
+  /**
+   * Asks for a region, resolving once `read` will answer for it.
+   *
+   * Calling it for a region already in flight joins that request
+   * rather than making a second one.
+   */
+  request(offset: number, size: number): Promise<void>;
+  /** Releases whatever is held. */
+  close(): void;
+}
+/** A file already in memory, which is every file this framework read before. */
+declare function bufferSource(data: ArrayBuffer): ByteSource;
+/**
+ * How much is fetched at a time.
+ *
+ * Big enough that a request is worth its round trip — a quarter of a
+ * megabyte is a second or two of ordinary video, so a clip playing
+ * forwards asks for one every second or so rather than every frame —
+ * and small enough that a seek does not drag a great deal of video
+ * nobody will watch.
+ *
+ * It is also what a reader's first request should be, so that the
+ * bytes it read to find the header land on a block boundary and can
+ * be kept; see `prefetched`. A megabyte, the first value here, was
+ * larger than the whole of a short file, so the header probe could
+ * never seed a block and the front of the file was always fetched
+ * twice.
+ */
+declare const DEFAULT_BLOCK_SIZE: number;
+interface RangeSourceOptions {
+  /** Fetches `[start, end)`. Inclusive-exclusive, like every other range in this codebase. */
+  readonly fetchRange: (source: string, start: number, end: number) => Promise<ArrayBuffer>;
+  /** The file's length, which a caller usually learns from the same response that told it the head. */
+  readonly size: number;
+  readonly blockSize?: number;
+  readonly capacity?: number;
+  /**
+   * Bytes the caller has already fetched, starting at `start`.
+   *
+   * A reader almost always has some: finding the `moov` means reading
+   * the front of the file, and without this that read is thrown away
+   * and the first block is fetched all over again. On a short file
+   * that duplicate was most of the transfer.
+   *
+   * Only the *whole* blocks inside it are kept. A partial block at
+   * either end is dropped rather than stored short, because a block
+   * held short would answer `read` for bytes it does not have.
+   */
+  readonly prefetched?: {
+    readonly start: number;
+    readonly data: ArrayBuffer;
+  };
+}
+/**
+ * A file fetched a block at a time.
+ *
+ * Blocks rather than exact ranges, and aligned to their own size, so
+ * that two samples in the same part of the file share one request and
+ * so the cache can be keyed on a number. A sample straddling a block
+ * boundary is copied out of the two blocks either side of it; every
+ * other read is a view, which matters because the common case is a
+ * frame's worth of bytes on the way to a decoder.
+ *
+ * **Eviction is by last use, not by position.** A viewer who seeks
+ * backwards into what they just watched should find it still here, and
+ * a strictly forward-looking policy would have thrown it away.
+ */
+declare function rangeSource(source: string, options: RangeSourceOptions): ByteSource;
+//#endregion
+//#region src/media/WebVtt.d.ts
+/**
+ * Just enough WebVTT to put words under a picture.
+ *
+ * Here for the reason `Mp4Demuxer` is: the alternative is a dependency
+ * that brings a renderer, a positioning model and a CSS cascade with
+ * it, and `gesso-core` has one dependency. What a caption track is,
+ * stripped of the parts that only mean something in a document, is a
+ * sorted list of (start, end, text) — and that is a parse of about two
+ * hundred lines rather than a library.
+ *
+ * **What it reads.** The `WEBVTT` header and anything on that line, an
+ * optional cue identifier, a timing line with `-->` and the two
+ * timestamps around it, cue settings after the timings, and the
+ * payload lines until a blank one. `NOTE` blocks and `STYLE` blocks
+ * are skipped. Timestamps in both the `mm:ss.mmm` and `hh:mm:ss.mmm`
+ * spellings, because both are written.
+ *
+ * **What it does not.** Cue settings are parsed and kept but nothing
+ * here acts on them: `line`, `position`, `align`, `size` and `vertical`
+ * describe a placement against a video box, and placement is the
+ * caller's. They are carried rather than dropped so that a caller who
+ * wants them is not made to parse the file again. Inline markup —
+ * `<i>`, `<b>`, `<v Speaker>`, `<00:01.000>` — is **stripped to its
+ * text**, which is a decision rather than an omission: this framework
+ * draws a string, a voice span would have to become a style run, and a
+ * caption that showed its own angle brackets would be worse than one
+ * that lost its italics. `REGION` blocks are skipped for the same
+ * reason the settings are inert.
+ *
+ * **Errors are not thrown.** A caption file is content, usually
+ * someone else's, and a single malformed cue in a hundred is not a
+ * reason to show none of them. A block that cannot be read is skipped
+ * and counted; `VttTrack.skipped` is how a caller finds out. That is
+ * the opposite of the demuxer's rule, and deliberately so: a video
+ * that will not play is a failure worth reporting, and a caption that
+ * is missing a line is not.
+ */
+/** One caption: when it is on screen, and what it says. */
+interface VttCue {
+  /** The cue's identifier, when it had one. Not required to be unique. */
+  readonly id?: string;
+  /** Seconds. */
+  readonly start: number;
+  readonly end: number;
+  /** The payload with its markup stripped; newlines are kept as newlines. */
+  readonly text: string;
+  /**
+   * The cue settings, unparsed beyond being split into pairs — `line`,
+   * `position`, `align`, `size`, `vertical`. Empty for most cues.
+   */
+  readonly settings: Readonly<Record<string, string>>;
+}
+interface VttTrack {
+  /** Cues in the order they are shown, which is not always the order they were written. */
+  readonly cues: readonly VttCue[];
+  /** Anything after `WEBVTT` on the first line; encoders put a title or a tool name there. */
+  readonly header: string;
+  /** How many blocks could not be read. Zero for a well-formed file. */
+  readonly skipped: number;
+}
+/**
+ * Reads a `.vtt` file.
+ *
+ * Returns an empty track rather than throwing for a file that is not
+ * WebVTT at all, for the reason the docblock gives: a caption track is
+ * an enhancement, and an application that has to guard every one of
+ * these with a `try` will end up not showing captions at all.
+ */
+declare function parseWebVtt(source: string): VttTrack;
+/**
+ * The cue to show at a position, or null between cues.
+ *
+ * A linear scan from a hint rather than a binary search, and that is
+ * the right shape here rather than a concession: this is called once
+ * per frame with a position that has almost always moved by one frame,
+ * so the answer is nearly always the cue it was last time or the one
+ * after it. `from` is that hint — pass back the index this returned —
+ * and the scan is then O(1) for playback and O(n) only for a scrub,
+ * where a caption is not what is costing anything.
+ *
+ * **Overlapping cues.** WebVTT permits them and a transcript of two
+ * people talking over each other has them. This answers the one that
+ * *starts* latest among those covering the position, which is what a
+ * single-line caption should show: the newest thing said.
+ */
+declare function cueAt(cues: readonly VttCue[], seconds: number, from?: number): {
+  cue: VttCue | null;
+  index: number;
+};
 //#endregion
 //#region src/scheduler/PerformanceMarks.d.ts
 /**
@@ -15707,7 +16260,35 @@ type UiSemanticsMap = ReadonlyMap<string, UiSemanticsRecord>;
  *      is, carrying `disabled` — unavailable is a thing to announce,
  *      hidden is not.
  */
-declare function buildSemanticsTree(root: UiNode): UiSemanticsMap;
+declare function buildSemanticsTree(root: UiNode): Map<string, UiSemanticsRecord>;
+/**
+ * The records one subtree contributes, as if walked in place.
+ *
+ * For re-describing what changed without rebuilding the whole tree.
+ * `node` keeps the `parent` and `index` its existing record has, and
+ * everything below it is walked exactly as `buildSemanticsTree` would:
+ * a descendant's index is counted among the semantic children of
+ * whatever inside this subtree claims it, so the numbering is the same
+ * one a full walk produces.
+ *
+ * **That only holds when `node` itself carries a record.** A
+ * transparent node's children attach to its nearest semantic ancestor
+ * and are numbered among that ancestor's *other* children too — nodes
+ * outside this subtree — so a walk that started here would number them
+ * from zero and disagree with the tree. Null says so, and the caller
+ * has to rebuild the whole tree instead.
+ *
+ * `inert` is whether an ancestor above this subtree is disabled, which
+ * only the caller can know.
+ */
+declare function buildSemanticsSubtree(node: UiNode, parent: string | null, index: number, inert: boolean): Map<string, UiSemanticsRecord> | null;
+/**
+ * Whether an ancestor of `node` is disabled, which every record in its
+ * subtree inherits.
+ *
+ * A full walk carries this down; a subtree walk has to look it up.
+ */
+declare function semanticsInertAbove(node: UiNode): boolean;
 /**
  * Separates a run record's id from its node's.
  *
@@ -15811,5 +16392,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { PrimitiveCommand as $, SelectionHost as $a, PaintProps as $c, propertyValuesEqual as $d, noKeyModifiers as $f, capturePointer as $i, UiThemeExtensionOptions as $l, UiTweenOptions as $m, iconKey as $n, fillTextRects as $o, UiObjectFit as $p, GridPlacement as $r, lineLimit as $s, Canvas2DRenderer as $t, spanAtOffset as $u, markNow as A, ScrollSink as Aa, UiDefinition as Ac, validateGradient as Ad, isUiChild as Af, easings as Ah, formatExplanation as Ai, LazyAxis as Al, darkColors as Am, ScrollPositionArgs as An, caretVisibleAt as Ao, NodeProperty as Ap, focusRing as Ar, setSelectionRange as As, clearFontStacks as At, UiLayoutContext as Au, Mp3Header as B, FocusNotifier as Ba, ButtonProps as Bc, isFrLength as Bd, UiEventType as Bf, UiManualFrameClock as Bi, VirtualUpdate as Bl, UiTransitionSpec as Bm, SharedElementArgs as Bn, commandForKey as Bo, decorationRect as Bp, Transform as Br, TextMeasurer as Bs, PaintResolver as Bt, UiFontStretch as Bu, selectionRectsIn as C, formatShortcut as Ca, Grid as Cc, UiGradientStop as Cd, UiModifierTeardown as Cf, colorsEqual as Ch, LayoutStateExplanation as Ci, normalizeStates as Cl, UiShapeName as Cm, insetPadding as Cn, UiEnvironmentProvider as Co, LayoutStats as Cp, draggable as Cr, DEFAULT_LINE_HEIGHT_FACTOR as Cs, RenderHooks as Ct, UiTypographyExtensions as Cu, UiSchedulerOptions as D, PointerControllerOptions as Da, Stack as Dc, gradientsEqual as Dd, UiElement as Df, rgba as Dh, describeLength as Di, CompositionRange as Dl, shapesEqual as Dm, breakpoint as Dn, CARET_BLINK_MS as Do, constraintsEqual as Dp, Decorations as Dr, selectableTextNodes as Ds, WebGPUSurface as Dt, typographyEqual as Du, UiScheduler as E, UiKeyboardController as Ea, ScrollView as Ec, gradientPaint as Ed, UiChild as Ef, rgb8 as Eh, SizeDecision as Ei, validateStates as El, isShapeName as Em, SizeContainerArgs as En, EnvironmentNotifier as Eo, clampSize as Ep, autoFocus as Er, clearSelectionRange as Es, WebGPUCanvasHost as Et, isTypographyRole as Eu, Mp4VideoTrack as F, GestureInput as Fa, ChildrenBindingId as Fc, UiLength as Fd, UiEventListenerOptions as Ff, UiFrameClock as Fi, UiVirtualWindow as Fl, createEnvironmentKey as Fm, DefaultVideoResolverOptions as Fn, isReadOnly as Fo, DecorationFill as Fp, measure as Fr, ParagraphTextMeasurer as Fs, PaintPictureCache as Ft, defaultVisualState as Fu, CLIP_STRIDE_BYTES as G, clearOverrideProperty as Ga, EnvironmentProps as Gc, repeat as Gd, UiKeyboardEvent as Gf, isNodeInert as Gi, videoFrameSize as Gl, tween as Gm, ImageSources as Gn, PlacedTextRun as Go, UiBorderRadiusValue as Gp, getPropertyNames as Gr, TextWrap as Gs, PaintRecorder as Gt, UiTextDecoration as Gu, splitMp3Frames as H, UiFocusManager as Ha, CommonProps as Hc, isPercentLength as Hd, UiGestureEvent as Hf, UiTimerFrameClockOptions as Hi, lazySource as Hl, assertTransitionMap as Hm, sharedElement as Hn, isPrintable as Ho, paintsAfterChildren as Hp, contentOffset as Hr, TextRunMeasurer as Hs, tracePathData as Ht, UiFontVariant as Hu, demuxMp4Video as I, GestureRecognizerOptions as Ia, UiChildrenBinding as Ic, UiTrackSize as Id, UiInputDispatcher as If, UiFrameClockFactory as Ii, VIRTUAL_INDEX_PROP as Il, findEnvironmentKey as Im, VideoPlayback as In, nextCaretToggle as Io, DecorationRect as Ip, pressable as Ir, SpannedRuns as Is, PaintStats as It, hasVisualState as Iu, GlyphCommand as J, writeDeclaredProperty as Ja, GridItemProps as Jc, boxShadow as Jd, UiPointerEvent as Jf, CanvasPlatformSurface as Ji, lightTheme as Jl, UiAnimationOptions as Jm, IconCanvas as Jn, TextRunRect as Jo, UiCursor as Jp, propertyEffects as Jr, PlacedLine as Js, INSPECTOR_HEAT_MS as Jt, UiTextSpan as Ju, CLIP_STRIDE_FLOATS as K, overrideSources as Ka, FlexContainerProps as Kc, resolveLength as Kd, UiPinchEvent as Kf, isNodeSelectable as Ki, UiTheme as Kl, AnimatedCell as Km, iconSource as Kn, SpanPaint as Ko, UiColorValue as Kp, inheritedPropertyFlags as Kr, spannedRunsFor as Ks, PaintRecording as Kt, UiTextLink as Ku, Mp3Format as L, UiGestureRecognizer as La, UiGraphBuilder as Lc, auto as Ld, UiListenerErrorReporter as Lf, UiFrameTime as Li, VIRTUAL_LEAD_PROP as Ll, UiNodeType as Lm, VideoResolver as Ln, syncEditorValue as Lo, DecorationShape as Lp, UiModifierBundle as Lr, TextLine as Ls, paintPictures as Lt, visualState as Lu, performanceMarksEnabled as M, UiScrollability as Ma, UiBinding as Mc, FrLength as Md, UiPropValue as Mf, steps as Mh, withOverrideSource as Mi, LazyItemRenderer as Ml, LayoutRecord as Mm, VideoSourceArgs as Mn, editorOf as Mo, UiNodeTransitions as Mp, InteractiveOptions as Mr, FixedMetricsOptions as Ms, registerFontStack as Mt, isLayoutProtocol as Mu, setPerformanceMarks as N, UiWheelController as Na, UiGraph as Nc, MinMaxTrack as Nd, UiProps as Nf, UiFrame as Ni, LazyListOptions as Nl, UiEnvironment as Nm, videoSource as Nn, isEditableNode as No, UiPropertyOverride as Np, hoverable as Nr, FontMetrics as Ns, PaintCanvas as Nt, UiVisualState as Nu, MARK_PREFIX as O, UiPointerController as Oa, Text as Oc, linearGradient as Od, isComponentLikeElement as Of, UiEasing as Oh, describeOverrides as Oi, EditUnit as Ol, UiColors as Om, sizeContainer as On, CARET_WIDTH as Oo, tightenConstraints as Op, FocusRingOptions as Or, selectableTextOf as Os, createWebGPUSurface as Ot, MAX_MEASURES_PER_CHILD as Ou, Mp4Sample as P, isScrollContainer as Pa, UiEventBinding as Pc, PercentLength as Pd, UiEventListener as Pf, UiAnimationFrameClock as Pi, LazySourceArgs as Pl, UiEnvironmentKey as Pm, DefaultVideoResolver as Pn, isMultiline as Po, UiPropertyOverrides as Pp, interactive as Pr, ParagraphLayout as Ps, PaintCanvasFactory as Pt, UiVisualStateSet as Pu, NO_CLIP_INDEX as Q, SelectionControllerOptions as Qa, PaintElementProps as Qc, defineProperty as Qd, UiWheelEvent as Qf, UiPlatformAdapter as Qi, UiThemeExtension as Ql, UiTween as Qm, IconSpec as Qn, drawText as Qo, UiGridAutoFlow as Qp, GridItemRequest as Qr, lineIndexForOffset as Qs, CanvasTextMeasurer as Qt, resolvedSpansOf as Qu, Mp3Frame as R, PinchRecognizerOptions as Ra, BoxModelProps as Rc, fr as Rd, MOUSE_POINTER as Rf, UiHostFrameClock as Ri, VIRTUAL_WINDOW_PROP as Rl, DirtyFlags as Rm, canDecodeVideo as Rn, EditCommand as Ro, DecorationStroke as Rp, bundle as Rr, TextLineRun as Rs, PaintContext2D as Rt, visualStatesEqual as Ru, paragraphGeometryFrom as S, UiShortcutStep as Sa, EditableText as Sc, UiGradientOffset as Sd, UiModifierHost as Sf, colorValuesEqual as Sh, LayoutExplanation as Si, isUiSemanticState as Sl, UiShapeExtensions as Sm, PublishInsetArgs as Sn, findMatchesIn as So, LayoutResult as Sp, DraggableOptions as Sr, resolvePaintState as Ss, DrawStats as St, UiTypography as Su, UiFrameCallback as T, KeyboardControllerOptions as Ta, Row as Tc, UiRadialGradient as Td, ComponentLikeElement as Tf, parseColor as Th, RelayoutExplanation as Ti, validateRole as Tl, defaultShapes as Tm, BreakpointArgs as Tn, UiEnvironmentKeys as To, TightenOptions as Tp, clickOutside as Tr, TextRange as Ts, WebGPURendererOptions as Tt, defaultTypography as Tu, WebGPUGlyphPages as U, NodeTransitions as Ua, ContainerProps as Uc, minmax as Ud, UiInputEvent as Uf, isNodeFocusable as Ui, UiVideoSurface as Ul, normalizeTransition as Um, IconSourceArgs as Un, EditableLayout as Uo, UI_SUBGRID_AXES as Up, closestPropertyName as Ur, TextRunSpan as Us, EMPTY_RECORDING as Ut, UiResolvedTextSpan as Uu, readMp3Header as V, FocusSource as Va, ColumnProps as Vc, isMinMaxTrack as Vd, UiFocusEvent as Vf, UiTimerFrameClock as Vi, VirtualViewport as Vl, UiTransitionValue as Vm, motion as Vn, detectEditingPlatform as Vo, hasDecorationPhase as Vp, accumulatedOffsetTo as Vr, TextOverflow as Vs, PaintTarget as Vt, UiFontStyle as Vu, Affine as W, resetTransitionWarnings as Wa, EditableTextProps as Wc, percent as Wd, UiKeyModifiers as Wf, isNodeHitTestable as Wi, isVideoSurface as Wl, spring as Wm, ImageSourceArgs as Wn, CanvasTextStyle as Wo, UiAlignment as Wp, findPropertyDefinition as Wr, TextRunStyle as Ws, PaintOp as Wt, UiSpannedText as Wu, INSTANCE_STRIDE_FLOATS as X, FindHost as Xa, IdentityProps as Xc, boxShadowsEqual as Xd, UiTextChangeEvent as Xf, PlatformEventTarget as Xi, withContrast as Xl, UiSpring as Xm, IconRasterizer as Xn, buildFontString as Xo, UiFlexWrap as Xp, propertyValuesEqualByName as Xr, caretRectFor as Xs, LayoutInspector as Xt, defaultTextStyle as Xu, INSTANCE_STRIDE_BYTES as Y, writeOverrideProperty as Ya, GridProps as Yc, boxShadowArraysEqual as Yd, UiPointerKind as Yf, PlatformAdapterOptions as Yi, themesEqual as Yl, UiReducedMotionPolicy as Ym, IconContext as Yn, applyCanvasTextStyle as Yo, UiDirection as Yp, propertyIsInherited as Yr, RunMeasure as Ys, InspectorOverlay as Yt, UiTextStyle as Yu, ImageCommand as Z, UiFindController as Za, InteractionProps as Zc, UiPropertyDefinition as Zd, UiWheelDeltaMode as Zf, PlatformSurface as Zi, withDensity as Zl, UiSpringOptions as Zm, IconRasterizerOptions as Zn, createCanvasTextStyle as Zo, UiFontWeight as Zp, GridContribution as Zr, lineIndexAtY as Zs, LayoutInspectorOptions as Zt, flattenTextSpans as Zu, setLinkHover as _, dragSessionFor as _a, LazyListProps as _c, GradientPaint as _d, assertModifierList as _f, transformsEqual as _h, SCROLLBAR_LINGER_MS as _i, UiLiveRegion as _l, borderRadiusEqual as _m, resolveString as _n, clearMatchRanges as _o, slideUp as _p, ReorderableOptions as _r, computeObjectFitRect as _s, WebGPUTextureCache as _t, spacingEqual as _u, diffSemantics as a, EditingState as aa, lineEndAt as ac, PaintFillRule as ad, noInsets as af, UiSpringToken as ah, MainAxisAlignment as ai, StackProps as al, UiSubgridAxis as am, RenderContext as an, UiPoint as ao, MotionState as ap, ContextMenuOptions as ar, Canvas2DContext as as, TEXTURED_STRIDE_BYTES as at, themeExtensionsEqual as au, offsetAtPointIn as b, UiShortcutBinding as ba, Button as bc, ResolvedGradientStop as bd, defineModifier as bf, colorToHex as bh, CustomLayoutExplanation as bi, UiSemanticStates as bl, normalizeBorderRadius as bm, sameArgs as bn, FindMatch as bo, Constraints as bp, reorderable as br, normalizeTextAlign as bs, WebGPUError as bt, defaultShadows as bu, UiSemanticsMap as c, UiTouchScroller as ca, nextWordEnd as cc, PaintSurface as cd, UiContainerSizeSource as cf, interpolateColor as ch, parseMainAxisAlignment as ci, TypographyProps as cl, UiTextOverflowValue as cm, drawOverlayShapes as cn, SCROLLBAR_MIN_THUMB as co, ResolvedMotionState as cp, contextMenu as cr, DEFAULT_FONT_SIZE as cs, buildRenderList as ct, contrastRatio as cu, textRunOfRecordId as d, UiDragSession as da, wordRangeAt as dc, UiPaint as dd, unknownContainerSize as df, interpolatorFor as dh, ELLIPSIS as di, UiProperties as dl, UiVerticalAlign as dm, CanvasSurface as dn, ScrollbarThumb as do, pop as dp, PinchableOptions as dr, ObjectFit as ds, textRuns as dt, relativeLuminance as du, pointerDeviceOf as ea, offsetAtPoint as ec, spannedTextOf as ed, UiInsetEdge as ef, createTween as eh, GridTrack as ei, PositionProps as el, UiOverflow as em, Canvas2DRendererOptions as en, UiSelectionController as eo, wheelDeltaYOf as ep, DefaultImageResolver as er, layoutTextLines as es, PrimitiveKind as et, UiThemeExtensions as eu, clearLinkHover as f, UiDragState as fa, Responsive as fc, UiPath as fd, UiModifierEnvironment as ff, UiTransform as fh, layoutParagraph as fi, UiPropertyName as fl, validateSubgrid as fm, createCanvasSurface as fn, scrollbarThumb as fo, resolveMotionState as fp, ZoomState as fr, PaintState as fs, GlyphShaper as ft, UiDensity as fu, linkRunAtPointIn as g, UiFileDropMessage as ga, LazyGridProps as gc, UiImage as gd, UiUnknownModifierPropertyError as gf, transformIsIdentity as gh, SCROLLBAR_FADE_MS as gi, UI_SEMANTIC_STATES as gl, borderRadiusCorners as gm, resolvePropertyByName as gn, TEXT_MATCHES_PROP as go, slideFrom as gp, DropTargetOptions as gr, colorToCss as gs, WebGPUGlyphAtlas as gt, scaleSpacing as gu, linkOf as h, UiDroppedFile as ha, LazyGrid as hc, pathValuesEqual as hd, UiModifierSet as hf, transform as hh, LayoutEngine as hi, UI_ROLES as hl, borderRadius as hm, resolveProperty as hn, SubtreeBounds as ho, slideDown as hp, DragSourceOptions as hr, VerticalAlign as hs, GlyphUpload as ht, defaultSpacing as hu, UiSemanticsPatch as i, EditingHost as ia, graphemeBoundaries as ic, PaintBox as id, insetsEqual as if, UiSpringSpec as ih, CrossAxisAlignment as ii, ScrollViewProps as il, UiSelfAlignment as im, LayoutReader as in, UiHitTester as io, MotionChannel as ip, animateLayout as ir, textRunDecorations as is, ScissorRect as it, themeExtension as iu, measureSpan as j, UiScrollBehavior as ja, BindingId as jc, AutoLength as jd, isUiElement as jf, linear as jh, labelNode as ji, LazyGridOptions as jl, lightColors as jm, scrollPosition as jn, editorFor as jo, UiNode as jp, BUTTON_INTERACTION as jr, CharacterCountTextMeasurer as js, fontStackFor as jt, UiLayoutProtocol as ju, markInstant as k, ScrollContainerState as ka, createElement as kc, radialGradient as kd, isObservable$1 as kf, cubicBezier as kh, formatConstraints as ki, EditableTextModel as kl, colorsEqualPalette as km, ScrollOffset as kn, EDITOR_PROP as ko, NodeId as kp, decorated as kr, selectionRangeOf as ks, bumpFontStack as kt, UiLayoutChild as ku, UiSemanticsRecord as l, EXTERNAL_FILES as la, previousGraphemeStart as lc, PaintTextAlign as ld, bandOf as lf, interpolateNumber as lh, FlexDirection as li, UiEventProps as ll, UiTextWrapValue as lm, labelOrigin as ln, SCROLLBAR_THICKNESS as lo, fade as lp, shortcut as lr, DEFAULT_FONT_WEIGHT as ls, createTextCache as lt, highContrastColors as lu, linkHoverOf as m, UiDropZone as ma, LazyColumn as mc, paintValuesEqual as md, UiModifierLayout as mf, parseTransform as mh, LayoutNotifier as mi, UiPropertyValues as ml, UiBorderRadiuses as mm, resolveNumber as mn, scrollbarZoneAt as mo, scaleFrom as mp, AutoScrollOptions as mr, TextAlign as ms, GlyphSlot as mt, UiSpacing as mu, UiSemanticsBox as n, touchActionFor as na, offsetForVerticalMove as nc, textSpansEqual as nd, UiInsetSource as nf, UiEasingToken as nh, sizeGridTracks as ni, Reactive as nl, UiPointerEvents as nm, RendererBackend as nn, HitTestResult as no, MOTION_CHANNELS as np, ImageResolver as nr, runFontString as ns, RenderList as nt, hasThemeExtension as nu, recordsEqual as o, UiEditingController as oa, lineStartAt as oc, PaintLineCap as od, observeViewportInsets as of, defaultMotion as oh, parseAlignContent as oi, TextContentProps as ol, UiTextAlign as om, LABEL_PADDING_X as on, SCROLLBAR_HOVER_ZONE as oo, MotionStateInput as op, ShortcutOptions as or, Canvas2DGradient as os, TEXTURED_STRIDE_FLOATS as ot, withThemeExtension as ou, hasTextLinks as p, UiDropEffect as pa, ResponsiveProps as pc, inputsEqual as pd, UiModifierFocus as pf, UiTransforms as ph, proportionalFontMetrics as pi, UiPropertyValueOf as pl, UiBorderRadius as pm, resolveBoolean as pn, scrollbarThumbs as po, rotateFrom as pp, pinchable as pr, PaintTextSpan as ps, GLYPH_SUBPIXEL_PHASES as pt, densityFactors as pu, CommandKind as q, resetOverrideWarnings as qa, FlexItemProps as qc, UiBoxShadow as qd, UiPointerDevice as qf, resolveCursor as qi, darkTheme as ql, UiAnimation as qm, imageSource as qn, TextLinePlacement as qo, UiContentDistribution as qp, inheritedPropertyNames as qr, CaretRect as qs, replayPaint as qt, UiTextMetrics as qu, UiSemanticsUpdate as r, EditingControllerOptions as ra, selectionRects as rc, textStylesEqual as rd, UiInsets as rf, UiMotion as rh, AlignContent as ri, RowProps as rl, UiPosition as rm, UiRenderer as rn, HitTester as ro, MOTION_REST as rp, AnimateLayoutOptions as rr, textRunBackgrounds as rs, RenderTextCache as rt, noThemeExtensions as ru, TEXT_RUN_ID_SEPARATOR as s, TouchScrollerOptions as sa, nextGraphemeEnd as sc, PaintLineJoin as sd, UiContainerSize as sf, UiInterpolator as sh, parseCrossAxisAlignment as si, TextProps as sl, UiTextDirection as sm, OverlayShape as sn, SCROLLBAR_INSET as so, MotionTiming as sp, ShortcutsOptions as sr, DEFAULT_FONT_FAMILY as ss, TextRunDraw as st, UiContrast as su, UiSemanticsAction as t, prepareInputSurface as ta, offsetAtX as tc, textContentOf as td, UiInsetRegistry as tf, UiDurationToken as th, placeGridItems as ti, PropsOf as tl, UiPlacement as tm, traceRoundedRect as tn, HitTestLayoutReader as to, DirtyNodeSet as tp, DefaultImageResolverOptions as tr, runCanvasStyleInto as ts, RenderCommand as tt, defineThemeExtension as tu, buildSemanticsTree as u, UiDragPayload as ua, previousWordStart as uc, PaintTextStyle as ud, containerBands as uf, interpolateTransform as uh, parseFlexDirection as ui, UiNodeRef as ul, UiThemeColorName as um, CanvasHost as un, ScrollbarAxis as uo, isMotionRest as up, shortcuts as ur, DEFAULT_TEXT_COLOR as us, glyphCount as ut, raiseContrast as uu, ParagraphGeometry as v, ShortcutRegistryOptions as va, LazyRow as vc, MAX_GRADIENT_STOPS as vd, UiModifier as vf, UiBasicColors as vh, ScrollAdjustment as vi, UiRole as vl, borderRadiusIsZero as vm, ThemeTokenTarget as vn, matchRangesOf as vo, SharedClaim as vp, dragSource as vr, createPaintState as vs, initializeWebGPU as vt, spacingSteps as vu, wordRangeIn as w, parseShortcut as wa, Paint as wc, UiLinearGradient as wd, ComponentResolver as wf, normalizeColor as wh, OverrideSources as wi, statesEqual as wl, UiShapes as wm, publishInset as wn, provideEnvironment as wo, Size as wp, ClickOutsideOptions as wr, TEXT_SELECTION_PROP as ws, WebGPURenderer as wt, UiTypographyRole as wu, paragraphGeometry as x, UiShortcutRegistry as xa, Column as xc, UiGradient as xd, isUiModifier as xf, colorToRgba as xh, Edges as xi, isUiRole as xl, uniformBorderRadius as xm, InsetPaddingArgs as xn, FindOptions as xo, LayoutBox as xp, DragOffset as xr, normalizeVerticalAlign as xs, CapturedFrame as xt, shadowsEqual as xu, hasDrawnText as y, UiShortcut as ya, Box as yc, ResolvedGradient as yd, UiModifierKind as yf, UiColor as yh, AxisExplanation as yi, UiSemanticState as yl, borderRadiusValuesEqual as ym, themeTokens as yn, setMatchRanges as yo, UiSharedElements as yp, dropTarget as yr, isPaintVisible as ys, isWebGPUAvailable as yt, UiShadows as yu, Mp3Frames as z, UiPinchRecognizer as za, BoxProps as zc, isAutoLength as zd, UiBeforeInputEvent as zf, UiHostFrameClockOptions as zi, VirtualItemMeasure as zl, AnimationDriver as zm, MotionArgs as zn, EditingPlatform as zo, decorationColor as zp, noModifiers as zr, TextMeasureRequest as zs, PaintGradient as zt, UiFontKerning as zu };
-//# sourceMappingURL=index-DuZEAhyZ.d.ts.map
+export { Mp3Header as $, GestureRecognizerOptions as $a, UiChildrenBinding as $c, UiTrackSize as $d, UiInputDispatcher as $f, UiFrameClockFactory as $i, VIRTUAL_INDEX_PROP as $l, findEnvironmentKey as $m, VideoPlayback as $n, nextCaretToggle as $o, DecorationRect as $p, pressable as $r, SpannedRuns as $s, PaintResolver as $t, hasVisualState as $u, MARK_PREFIX as A, UiDropEffect as Aa, ResponsiveProps as Ac, inputsEqual as Ad, UiModifierFocus as Af, UiTransforms as Ah, proportionalFontMetrics as Ai, UiPropertyValueOf as Al, UiBorderRadius as Am, resolveString as An, scrollbarThumbs as Ao, rotateFrom as Ap, pinchable as Ar, PaintTextSpan as As, WebGPUTextureCache as At, densityFactors as Au, ByteSource as B, formatShortcut as Ba, Grid as Bc, UiGradientStop as Bd, UiModifierTeardown as Bf, colorsEqual as Bh, LayoutStateExplanation as Bi, normalizeStates as Bl, UiShapeName as Bm, breakpoint as Bn, UiEnvironmentProvider as Bo, LayoutStats as Bp, draggable as Br, DEFAULT_LINE_HEIGHT_FACTOR as Bs, WebGPUSurface as Bt, UiTypographyExtensions as Bu, paragraphGeometry as C, UiEditingController as Ca, lineStartAt as Cc, PaintLineCap as Cd, observeViewportInsets as Cf, defaultMotion as Ch, parseAlignContent as Ci, TextContentProps as Cl, UiTextAlign as Cm, CanvasHost as Cn, SCROLLBAR_HOVER_ZONE as Co, MotionStateInput as Cp, ShortcutOptions as Cr, Canvas2DGradient as Cs, glyphCount as Ct, withThemeExtension as Cu, UiFrameCallback as D, UiDragPayload as Da, previousWordStart as Dc, PaintTextStyle as Dd, containerBands as Df, interpolateTransform as Dh, parseFlexDirection as Di, UiNodeRef as Dl, UiThemeColorName as Dm, resolveNumber as Dn, ScrollbarAxis as Do, isMotionRest as Dp, shortcuts as Dr, DEFAULT_TEXT_COLOR as Ds, GlyphSlot as Dt, raiseContrast as Du, wordRangeIn as E, EXTERNAL_FILES as Ea, previousGraphemeStart as Ec, PaintTextAlign as Ed, bandOf as Ef, interpolateNumber as Eh, FlexDirection as Ei, UiEventProps as El, UiTextWrapValue as Em, resolveBoolean as En, SCROLLBAR_THICKNESS as Eo, fade as Ep, shortcut as Er, DEFAULT_FONT_WEIGHT as Es, GLYPH_SUBPIXEL_PHASES as Et, highContrastColors as Eu, setPerformanceMarks as F, ShortcutRegistryOptions as Fa, LazyRow as Fc, MAX_GRADIENT_STOPS as Fd, UiModifier as Ff, UiBasicColors as Fh, ScrollAdjustment as Fi, UiRole as Fl, borderRadiusIsZero as Fm, PublishInsetArgs as Fn, matchRangesOf as Fo, SharedClaim as Fp, dragSource as Fr, createPaintState as Fs, DrawStats as Ft, spacingSteps as Fu, Mp4AudioTrack as G, UiPointerController as Ga, Text as Gc, linearGradient as Gd, isComponentLikeElement as Gf, UiEasing as Gh, describeOverrides as Gi, EditUnit as Gl, UiColors as Gm, VideoClock as Gn, CARET_WIDTH as Go, tightenConstraints as Gp, FocusRingOptions as Gr, selectableTextOf as Gs, registerFontStack as Gt, MAX_MEASURES_PER_CHILD as Gu, RangeSourceOptions as H, KeyboardControllerOptions as Ha, Row as Hc, UiRadialGradient as Hd, ComponentLikeElement as Hf, parseColor as Hh, RelayoutExplanation as Hi, validateRole as Hl, defaultShapes as Hm, ScrollOffset as Hn, UiEnvironmentKeys as Ho, TightenOptions as Hp, clickOutside as Hr, TextRange as Hs, bumpFontStack as Ht, defaultTypography as Hu, VttCue as I, UiShortcut as Ia, Box as Ic, ResolvedGradient as Id, UiModifierKind as If, UiColor as Ih, AxisExplanation as Ii, UiSemanticState as Il, borderRadiusValuesEqual as Im, insetPadding as In, setMatchRanges as Io, UiSharedElements as Ip, dropTarget as Ir, isPaintVisible as Is, RenderHooks as It, UiShadows as Iu, demuxMp4Audio as J, UiScrollBehavior as Ja, BindingId as Jc, AutoLength as Jd, isUiElement as Jf, linear as Jh, labelNode as Ji, LazyGridOptions as Jl, lightColors as Jm, VideoTransport as Jn, editorFor as Jo, UiNode as Jp, BUTTON_INTERACTION as Jr, CharacterCountTextMeasurer as Js, PaintPictureCache as Jt, UiLayoutProtocol as Ju, Mp4Sample as K, ScrollContainerState as Ka, createElement as Kc, radialGradient as Kd, isObservable$1 as Kf, cubicBezier as Kh, formatConstraints as Ki, EditableTextModel as Kl, colorsEqualPalette as Km, VideoSourceArgs as Kn, EDITOR_PROP as Ko, NodeId as Kp, decorated as Kr, selectionRangeOf as Ks, PaintCanvas as Kt, UiLayoutChild as Ku, VttTrack as L, UiShortcutBinding as La, Button as Lc, ResolvedGradientStop as Ld, defineModifier as Lf, colorToHex as Lh, CustomLayoutExplanation as Li, UiSemanticStates as Ll, normalizeBorderRadius as Lm, publishInset as Ln, FindMatch as Lo, Constraints as Lp, reorderable as Lr, normalizeTextAlign as Ls, WebGPURenderer as Lt, defaultShadows as Lu, markNow as M, UiDroppedFile as Ma, LazyGrid as Mc, pathValuesEqual as Md, UiModifierSet as Mf, transform as Mh, LayoutEngine as Mi, UI_ROLES as Ml, borderRadius as Mm, themeTokens as Mn, SubtreeBounds as Mo, slideDown as Mp, DragSourceOptions as Mr, VerticalAlign as Ms, isWebGPUAvailable as Mt, defaultSpacing as Mu, measureSpan as N, UiFileDropMessage as Na, LazyGridProps as Nc, UiImage as Nd, UiUnknownModifierPropertyError as Nf, transformIsIdentity as Nh, SCROLLBAR_FADE_MS as Ni, UI_SEMANTIC_STATES as Nl, borderRadiusCorners as Nm, sameArgs as Nn, TEXT_MATCHES_PROP as No, slideFrom as Np, DropTargetOptions as Nr, colorToCss as Ns, WebGPUError as Nt, scaleSpacing as Nu, UiScheduler as O, UiDragSession as Oa, wordRangeAt as Oc, UiPaint as Od, unknownContainerSize as Of, interpolatorFor as Oh, ELLIPSIS as Oi, UiProperties as Ol, UiVerticalAlign as Om, resolveProperty as On, ScrollbarThumb as Oo, pop as Op, PinchableOptions as Or, ObjectFit as Os, GlyphUpload as Ot, relativeLuminance as Ou, performanceMarksEnabled as P, dragSessionFor as Pa, LazyListProps as Pc, GradientPaint as Pd, assertModifierList as Pf, transformsEqual as Ph, SCROLLBAR_LINGER_MS as Pi, UiLiveRegion as Pl, borderRadiusEqual as Pm, InsetPaddingArgs as Pn, clearMatchRanges as Po, slideUp as Pp, ReorderableOptions as Pr, computeObjectFitRect as Ps, CapturedFrame as Pt, spacingEqual as Pu, Mp3Frames as Q, GestureInput as Qa, ChildrenBindingId as Qc, UiLength as Qd, UiEventListenerOptions as Qf, UiFrameClock as Qi, UiVirtualWindow as Ql, createEnvironmentKey as Qm, RangeResponse as Qn, isReadOnly as Qo, DecorationFill as Qp, measure as Qr, ParagraphTextMeasurer as Qs, PaintGradient as Qt, defaultVisualState as Qu, cueAt as R, UiShortcutRegistry as Ra, Column as Rc, UiGradient as Rd, isUiModifier as Rf, colorToRgba as Rh, Edges as Ri, isUiRole as Rl, uniformBorderRadius as Rm, BreakpointArgs as Rn, FindOptions as Ro, LayoutBox as Rp, DragOffset as Rr, normalizeVerticalAlign as Rs, WebGPURendererOptions as Rt, shadowsEqual as Ru, offsetAtPointIn as S, EditingState as Sa, lineEndAt as Sc, PaintFillRule as Sd, noInsets as Sf, UiSpringToken as Sh, MainAxisAlignment as Si, StackProps as Sl, UiSubgridAxis as Sm, labelOrigin as Sn, UiPoint as So, MotionState as Sp, ContextMenuOptions as Sr, Canvas2DContext as Ss, createTextCache as St, themeExtensionsEqual as Su, selectionRectsIn as T, UiTouchScroller as Ta, nextWordEnd as Tc, PaintSurface as Td, UiContainerSizeSource as Tf, interpolateColor as Th, parseMainAxisAlignment as Ti, TypographyProps as Tl, UiTextOverflowValue as Tm, createCanvasSurface as Tn, SCROLLBAR_MIN_THUMB as To, ResolvedMotionState as Tp, contextMenu as Tr, DEFAULT_FONT_SIZE as Ts, GlyphShaper as Tt, contrastRatio as Tu, bufferSource as U, UiKeyboardController as Ua, ScrollView as Uc, gradientPaint as Ud, UiChild as Uf, rgb8 as Uh, SizeDecision as Ui, validateStates as Ul, isShapeName as Um, ScrollPositionArgs as Un, EnvironmentNotifier as Uo, clampSize as Up, autoFocus as Ur, clearSelectionRange as Us, clearFontStacks as Ut, isTypographyRole as Uu, DEFAULT_BLOCK_SIZE as V, parseShortcut as Va, Paint as Vc, UiLinearGradient as Vd, ComponentResolver as Vf, normalizeColor as Vh, OverrideSources as Vi, statesEqual as Vl, UiShapes as Vm, sizeContainer as Vn, provideEnvironment as Vo, Size as Vp, ClickOutsideOptions as Vr, TEXT_SELECTION_PROP as Vs, createWebGPUSurface as Vt, UiTypographyRole as Vu, rangeSource as W, PointerControllerOptions as Wa, Stack as Wc, gradientsEqual as Wd, UiElement as Wf, rgba as Wh, describeLength as Wi, CompositionRange as Wl, shapesEqual as Wm, scrollPosition as Wn, CARET_BLINK_MS as Wo, constraintsEqual as Wp, Decorations as Wr, selectableTextNodes as Ws, fontStackFor as Wt, typographyEqual as Wu, Mp3Format as X, UiWheelController as Xa, UiGraph as Xc, MinMaxTrack as Xd, UiProps as Xf, UiFrame as Xi, LazyListOptions as Xl, UiEnvironment as Xm, DefaultVideoResolver as Xn, isEditableNode as Xo, UiPropertyOverride as Xp, hoverable as Xr, FontMetrics as Xs, paintPictures as Xt, UiVisualState as Xu, demuxMp4Video as Y, UiScrollability as Ya, UiBinding as Yc, FrLength as Yd, UiPropValue as Yf, steps as Yh, withOverrideSource as Yi, LazyItemRenderer as Yl, LayoutRecord as Ym, videoSource as Yn, editorOf as Yo, UiNodeTransitions as Yp, InteractiveOptions as Yr, FixedMetricsOptions as Ys, PaintStats as Yt, isLayoutProtocol as Yu, Mp3Frame as Z, isScrollContainer as Za, UiEventBinding as Zc, PercentLength as Zd, UiEventListener as Zf, UiAnimationFrameClock as Zi, LazySourceArgs as Zl, UiEnvironmentKey as Zm, DefaultVideoResolverOptions as Zn, isMultiline as Zo, UiPropertyOverrides as Zp, interactive as Zr, ParagraphLayout as Zs, PaintContext2D as Zt, UiVisualStateSet as Zu, linkOf as _, pointerDeviceOf as _a, offsetAtPoint as _c, spannedTextOf as _d, UiInsetEdge as _f, createTween as _h, GridTrack as _i, PositionProps as _l, UiOverflow as _m, LayoutReader as _n, UiSelectionController as _o, wheelDeltaYOf as _p, DefaultImageResolver as _r, layoutTextLines as _s, ScissorRect as _t, UiThemeExtensions as _u, diffSemantics as a, UiTimerFrameClockOptions as aa, TextRunMeasurer as ac, UiFontVariant as ad, isPercentLength as af, assertTransitionMap as ah, contentOffset as ai, CommonProps as al, paintsAfterChildren as am, PaintRecording as an, UiFocusManager as ao, UiGestureEvent as ap, sharedElement as ar, isPrintable as as, CLIP_STRIDE_FLOATS as at, lazySource as au, ParagraphGeometry as b, EditingControllerOptions as ba, selectionRects as bc, textStylesEqual as bd, UiInsets as bf, UiMotion as bh, AlignContent as bi, RowProps as bl, UiPosition as bm, OverlayShape as bn, HitTester as bo, MOTION_REST as bp, AnimateLayoutOptions as br, textRunBackgrounds as bs, TextRunDraw as bt, noThemeExtensions as bu, UiSemanticsMap as c, isNodeInert as ca, TextWrap as cc, UiTextDecoration as cd, repeat as cf, tween as ch, getPropertyNames as ci, EnvironmentProps as cl, UiBorderRadiusValue as cm, InspectorOverlay as cn, clearOverrideProperty as co, UiKeyboardEvent as cp, ImageSources as cr, PlacedTextRun as cs, INSTANCE_STRIDE_BYTES as ct, videoFrameSize as cu, buildSemanticsTree as d, CanvasPlatformSurface as da, PlacedLine as dc, UiTextSpan as dd, boxShadow as df, UiAnimationOptions as dh, propertyEffects as di, GridItemProps as dl, UiCursor as dm, CanvasTextMeasurer as dn, writeDeclaredProperty as do, UiPointerEvent as dp, IconCanvas as dr, TextRunRect as ds, NO_CLIP_INDEX as dt, lightTheme as du, UiFrameTime as ea, TextLine as ec, visualState as ed, auto as ef, UiNodeType as eh, UiModifierBundle as ei, UiGraphBuilder as el, DecorationShape as em, PaintTarget as en, UiGestureRecognizer as eo, UiListenerErrorReporter as ep, VideoResolver as er, syncEditorValue as es, readMp3Header as et, VIRTUAL_LEAD_PROP as eu, semanticsInertAbove as f, PlatformAdapterOptions as fa, RunMeasure as fc, UiTextStyle as fd, boxShadowArraysEqual as ff, UiReducedMotionPolicy as fh, propertyIsInherited as fi, GridProps as fl, UiDirection as fm, Canvas2DRenderer as fn, writeOverrideProperty as fo, UiPointerKind as fp, IconContext as fr, applyCanvasTextStyle as fs, PrimitiveCommand as ft, themesEqual as fu, linkHoverOf as g, capturePointer as ga, lineLimit as gc, spanAtOffset as gd, propertyValuesEqual as gf, UiTweenOptions as gh, GridPlacement as gi, PaintProps as gl, UiObjectFit as gm, UiRenderer as gn, SelectionHost as go, noKeyModifiers as gp, iconKey as gr, fillTextRects as gs, RenderTextCache as gt, UiThemeExtensionOptions as gu, hasTextLinks as h, UiPlatformAdapter as ha, lineIndexForOffset as hc, resolvedSpansOf as hd, defineProperty as hf, UiTween as hh, GridItemRequest as hi, PaintElementProps as hl, UiGridAutoFlow as hm, RendererBackend as hn, SelectionControllerOptions as ho, UiWheelEvent as hp, IconSpec as hr, drawText as hs, RenderList as ht, UiThemeExtension as hu, UiSemanticsPatch as i, UiTimerFrameClock as ia, TextOverflow as ic, UiFontStyle as id, isMinMaxTrack as if, UiTransitionValue as ih, accumulatedOffsetTo as ii, ColumnProps as il, hasDecorationPhase as im, PaintRecorder as in, FocusSource as io, UiFocusEvent as ip, motion as ir, detectEditingPlatform as is, CLIP_STRIDE_BYTES as it, VirtualViewport as iu, markInstant as j, UiDropZone as ja, LazyColumn as jc, paintValuesEqual as jd, UiModifierLayout as jf, parseTransform as jh, LayoutNotifier as ji, UiPropertyValues as jl, UiBorderRadiuses as jm, ThemeTokenTarget as jn, scrollbarZoneAt as jo, scaleFrom as jp, AutoScrollOptions as jr, TextAlign as js, initializeWebGPU as jt, UiSpacing as ju, UiSchedulerOptions as k, UiDragState as ka, Responsive as kc, UiPath as kd, UiModifierEnvironment as kf, UiTransform as kh, layoutParagraph as ki, UiPropertyName as kl, validateSubgrid as km, resolvePropertyByName as kn, scrollbarThumb as ko, resolveMotionState as kp, ZoomState as kr, PaintState as ks, WebGPUGlyphAtlas as kt, UiDensity as ku, UiSemanticsRecord as l, isNodeSelectable as la, spannedRunsFor as lc, UiTextLink as ld, resolveLength as lf, AnimatedCell as lh, inheritedPropertyFlags as li, FlexContainerProps as ll, UiColorValue as lm, LayoutInspector as ln, overrideSources as lo, UiPinchEvent as lp, iconSource as lr, SpanPaint as ls, INSTANCE_STRIDE_FLOATS as lt, UiTheme as lu, clearLinkHover as m, PlatformSurface as ma, lineIndexAtY as mc, flattenTextSpans as md, UiPropertyDefinition as mf, UiSpringOptions as mh, GridContribution as mi, InteractionProps as ml, UiFontWeight as mm, traceRoundedRect as mn, UiFindController as mo, UiWheelDeltaMode as mp, IconRasterizerOptions as mr, createCanvasTextStyle as ms, RenderCommand as mt, withDensity as mu, UiSemanticsBox as n, UiHostFrameClockOptions as na, TextMeasureRequest as nc, UiFontKerning as nd, isAutoLength as nf, AnimationDriver as nh, noModifiers as ni, BoxProps as nl, decorationColor as nm, EMPTY_RECORDING as nn, UiPinchRecognizer as no, UiBeforeInputEvent as np, MotionArgs as nr, EditingPlatform as ns, WebGPUGlyphPages as nt, VirtualItemMeasure as nu, recordsEqual as o, isNodeFocusable as oa, TextRunSpan as oc, UiResolvedTextSpan as od, minmax as of, normalizeTransition as oh, closestPropertyName as oi, ContainerProps as ol, UI_SUBGRID_AXES as om, replayPaint as on, NodeTransitions as oo, UiInputEvent as op, IconSourceArgs as or, EditableLayout as os, CommandKind as ot, UiVideoSurface as ou, textRunOfRecordId as p, PlatformEventTarget as pa, caretRectFor as pc, defaultTextStyle as pd, boxShadowsEqual as pf, UiSpring as ph, propertyValuesEqualByName as pi, IdentityProps as pl, UiFlexWrap as pm, Canvas2DRendererOptions as pn, FindHost as po, UiTextChangeEvent as pp, IconRasterizer as pr, buildFontString as ps, PrimitiveKind as pt, withContrast as pu, Mp4VideoTrack as q, ScrollSink as qa, UiDefinition as qc, validateGradient as qd, isUiChild as qf, easings as qh, formatExplanation as qi, LazyAxis as ql, darkColors as qm, VideoState as qn, caretVisibleAt as qo, NodeProperty as qp, focusRing as qr, setSelectionRange as qs, PaintCanvasFactory as qt, UiLayoutContext as qu, UiSemanticsUpdate as r, UiManualFrameClock as ra, TextMeasurer as rc, UiFontStretch as rd, isFrLength as rf, UiTransitionSpec as rh, Transform as ri, ButtonProps as rl, decorationRect as rm, PaintOp as rn, FocusNotifier as ro, UiEventType as rp, SharedElementArgs as rr, commandForKey as rs, Affine as rt, VirtualUpdate as ru, TEXT_RUN_ID_SEPARATOR as s, isNodeHitTestable as sa, TextRunStyle as sc, UiSpannedText as sd, percent as sf, spring as sh, findPropertyDefinition as si, EditableTextProps as sl, UiAlignment as sm, INSPECTOR_HEAT_MS as sn, resetTransitionWarnings as so, UiKeyModifiers as sp, ImageSourceArgs as sr, CanvasTextStyle as ss, GlyphCommand as st, isVideoSurface as su, UiSemanticsAction as t, UiHostFrameClock as ta, TextLineRun as tc, visualStatesEqual as td, fr as tf, DirtyFlags as th, bundle as ti, BoxModelProps as tl, DecorationStroke as tm, tracePathData as tn, PinchRecognizerOptions as to, MOUSE_POINTER as tp, canDecodeVideo as tr, EditCommand as ts, splitMp3Frames as tt, VIRTUAL_WINDOW_PROP as tu, buildSemanticsSubtree as u, resolveCursor as ua, CaretRect as uc, UiTextMetrics as ud, UiBoxShadow as uf, UiAnimation as uh, inheritedPropertyNames as ui, FlexItemProps as ul, UiContentDistribution as um, LayoutInspectorOptions as un, resetOverrideWarnings as uo, UiPointerDevice as up, imageSource as ur, TextLinePlacement as us, ImageCommand as ut, darkTheme as uu, linkRunAtPointIn as v, prepareInputSurface as va, offsetAtX as vc, textContentOf as vd, UiInsetRegistry as vf, UiDurationToken as vh, placeGridItems as vi, PropsOf as vl, UiPlacement as vm, RenderContext as vn, HitTestLayoutReader as vo, DirtyNodeSet as vp, DefaultImageResolverOptions as vr, runCanvasStyleInto as vs, TEXTURED_STRIDE_BYTES as vt, defineThemeExtension as vu, paragraphGeometryFrom as w, TouchScrollerOptions as wa, nextGraphemeEnd as wc, PaintLineJoin as wd, UiContainerSize as wf, UiInterpolator as wh, parseCrossAxisAlignment as wi, TextProps as wl, UiTextDirection as wm, CanvasSurface as wn, SCROLLBAR_INSET as wo, MotionTiming as wp, ShortcutsOptions as wr, DEFAULT_FONT_FAMILY as ws, textRuns as wt, UiContrast as wu, hasDrawnText as x, EditingHost as xa, graphemeBoundaries as xc, PaintBox as xd, insetsEqual as xf, UiSpringSpec as xh, CrossAxisAlignment as xi, ScrollViewProps as xl, UiSelfAlignment as xm, drawOverlayShapes as xn, UiHitTester as xo, MotionChannel as xp, animateLayout as xr, textRunDecorations as xs, buildRenderList as xt, themeExtension as xu, setLinkHover as y, touchActionFor as ya, offsetForVerticalMove as yc, textSpansEqual as yd, UiInsetSource as yf, UiEasingToken as yh, sizeGridTracks as yi, Reactive as yl, UiPointerEvents as ym, LABEL_PADDING_X as yn, HitTestResult as yo, MOTION_CHANNELS as yp, ImageResolver as yr, runFontString as ys, TEXTURED_STRIDE_FLOATS as yt, hasThemeExtension as yu, parseWebVtt as z, UiShortcutStep as za, EditableText as zc, UiGradientOffset as zd, UiModifierHost as zf, colorValuesEqual as zh, LayoutExplanation as zi, isUiSemanticState as zl, UiShapeExtensions as zm, SizeContainerArgs as zn, findMatchesIn as zo, LayoutResult as zp, DraggableOptions as zr, resolvePaintState as zs, WebGPUCanvasHost as zt, UiTypography as zu };
+//# sourceMappingURL=index-DAdauEn9.d.ts.map