foldkit-primitives 0.15.4 → 0.16.0

package/dist/dom/index.d.mts

@@ -1,714 +0,0 @@
-import { A as Moved, C as TargetPressed, D as Move, E as Fact, M as ScrollLock, N as FocusScope, O as MoveEnded, P as tabbableWithin, S as TargetHovered, T as targetOf, _ as HOLD_TO_DRAG_MS, a as TextEdited, b as zoneOf, c as DRAG_THRESHOLD, d as DragFact, f as DragPlace, g as HOLD_SLOP, h as DraggedOver, i as TextCommitted, j as HideOutside, k as MoveStarted, l as DragCancelled, m as DragZone, n as EditableText, o as TextFact, p as DragStarted, r as TextCancelled, s as textOf, t as EditAsked, u as DragDropped, v as PointerDrag, w as Targets, x as TargetFact, y as boxOf } from "../editable-text-Bg7vil7h.mjs";
-import { Schema, Stream } from "effect";
-import * as Mount from "foldkit/mount";
-import { Url } from "foldkit/url";
-import { Command } from "foldkit/command";
-export declare const Focused: Schema.TaggedStruct<"Focused", {}>;
-export type Focused = typeof Focused.Type;
-/**
- * Autofocus as a Mount: focuses the element on insert, then emits `Focused`.
- * The message means focus was requested — a non-focusable element or a
- * hidden tab may decline, and the browser does not report that. Plain
- * `focus()`, no scroll options: scroll behavior stays the application's
- * choice.
- */
-export declare const Autofocus: Mount.MountDefinitionNoArgs<"Autofocus", {
-  readonly _tag: "Focused";
-}>;
-export declare const ClipboardMessage: import("foldkit/message").MessageUnion<{
-  readonly Copied: {};
-  readonly CopyFailed: {
-    message: Schema.String;
-  };
-}>;
-export type ClipboardMessage = typeof ClipboardMessage.Type;
-export declare const ClipboardReadMessage: import("foldkit/message").MessageUnion<{
-  readonly Read: {
-    text: Schema.String;
-  };
-  readonly ReadFailed: {
-    message: Schema.String;
-  };
-}>;
-export type ClipboardReadMessage = typeof ClipboardReadMessage.Type;
-/**
- * Copies text to the clipboard. Without a clipboard API (SSR, insecure
- * context, denied permission) the command yields `CopyFailed` instead of
- * throwing, so `update` handles both outcomes as Messages.
- */
-export declare const copyText: (text: string) => Command<ClipboardMessage, never, never>;
-/**
- * Reads the clipboard's text. The browser may ask the user first; a refusal,
- * an insecure context or no clipboard API yields `ReadFailed`.
- */
-export declare const readText: () => Command<ClipboardReadMessage, never, never>;
-/** What `InputMask` reports after each edit: the masked text shown, and the characters typed. */
-export declare const Input: Schema.TaggedStruct<"Input", {
-  readonly value: Schema.String;
-  readonly raw: Schema.String;
-}>;
-export type Input = typeof Input.Type;
-/**
- * The mask as a pure function: `#` takes a digit, `A` a letter, `*` either, and
- * any other character of the pattern is written in once input reaches past it.
- * Input that fits no placeholder is skipped. `masked` is what the field shows;
- * `raw` is only the characters typed.
- */
-export declare const applyMask: (value: string, pattern: string) => {
-  readonly masked: string;
-  readonly raw: string;
-};
-/**
- * An input mask as a Mount plus a pure mask function. The pattern language
- * is three placeholders — `#` digit, `A` letter, `*` either, all ASCII —
- * with every other character literal. Literals appear only once a later placeholder
- * consumes input, so partial values never dangle a separator. The Mount
- * rewrites the field, restores the caret approximately, and emits `Input`
- * with both the masked and raw values; the parent owns the state, like any
- * controlled input.
- */
-export declare const InputMask: Mount.MountDefinitionWithArgs<"InputMask", {
-  pattern: Schema.String;
-}, {
-  readonly _tag: "Input";
-  readonly value: string;
-  readonly raw: string;
-}>;
-/**
- * Keeps what is marked in view as a Mount: whenever an element in the mounted
- * one's subtree newly matches `selector`, such as the row just selected in a
- * list, it is scrolled into view the least amount that shows it (`nearest`).
- * The element keeps its identity and its focus: nothing is redrawn to move it.
- *
- * It watches with a `MutationObserver` for as long as it is mounted, which is as
- * long as the list or canvas that can change what is marked.
- */
-export declare const KeepInView: Mount.MountDefinitionWithArgs<"KeepInView", {
-  /** What is marked, as a selector within the element: `[aria-selected="true"]`. */
-  selector: Schema.String;
-}, never>;
-export declare const ScriptMessage: import("foldkit/message").MessageUnion<{
-  readonly Loaded: {};
-  readonly LoadFailed: {
-    message: Schema.String;
-  };
-}>;
-export type ScriptMessage = typeof ScriptMessage.Type;
-/** Loads a script by URL, once per URL. */
-export declare const loadScript: (src: string) => Command<ScriptMessage, never, never>;
-export declare const ShareData: Schema.Struct<{
-  readonly title: Schema.optional<Schema.String>;
-  readonly text: Schema.optional<Schema.String>;
-  readonly url: Schema.optional<Schema.String>;
-}>;
-export type ShareData = typeof ShareData.Type;
-export declare const ShareMessage: import("foldkit/message").MessageUnion<{
-  readonly Shared: {};
-  readonly Dismissed: {};
-  readonly ShareFailed: {
-    message: Schema.String;
-  };
-}>;
-export type ShareMessage = typeof ShareMessage.Type;
-/** Shares data through the platform sheet. */
-export declare const share: (data: ShareData) => Command<ShareMessage, never, never>;
-/** The custom properties `Measure` writes for a target named `name`. */
-export declare const measured: (name: string) => {
-  readonly x: `--fk-${string}-x`;
-  readonly y: `--fk-${string}-y`;
-  readonly w: `--fk-${string}-w`;
-  readonly h: `--fk-${string}-h`;
-  readonly display: `--fk-${string}-display`;
-  /**
-   * `1` for the measure that finds the mark on another element than the
-   * last, `0` for any other (the layout moved or resized the same one, or
-   * it is the first found): an overlay that glides to a new mark scales its
-   * duration by it, so it keeps to its element as the layout settles.
-   */
-  readonly moving: `--fk-${string}-moving`;
-};
-/**
- * Measures marked elements as a Mount, for a view to draw something over them,
- * such as an editor's selection outline, with no Message and no Model: where
- * an element is, is presentation, known to the DOM and to no transition.
- *
- * For each named target, the first element in the mounted one's subtree that
- * matches its selector is measured relative to the mounted element's scroll
- * box, which is what an absolutely placed child of it is laid out in. The
- * mounted element gets `--fk-<name>-x`, `-y`, `-w` and `-h` in pixels, and
- * `--fk-<name>-display`: `block` while a target is found, `none` while none is,
- * and `--fk-<name>-moving` (see `measured`).
- *
- * It measures again when the subtree changes (a selection moves) or the
- * mounted element or a measured one changes size, in the frame the change is
- * drawn in; and, at most once a frame, when the mounted element scrolls, the
- * window resizes, an image or a font inside loads, and on every frame of a
- * transition or an animation inside. What moves a target by any other way,
- * such as a stylesheet added that shifts it without resizing it, is seen at
- * the next of these.
- */
-export declare const Measure: Mount.MountDefinitionWithArgs<"Measure", {
-  /** Each target by name, as a selector within the element: `{ selected: '[aria-selected="true"]' }`. */
-  targets: Schema.$Record<Schema.String, Schema.String>;
-}, never>;
-/**
- * Keeps focus that is inside a container of roving tab stops on its stop, as a
- * Mount: when a transition moves the stop (a row made current by a command the
- * container did not see, such as a duplicate) or removes the focused
- * descendant (a deleted row), focus goes to the descendant with
- * `tabindex="0"`. It sends no Message. Focus outside the container is never
- * taken, and focus the user moved away stays where it went.
- */
-export declare const FollowTabStop: Mount.MountDefinitionNoArgs<"FollowTabStop", never>;
-/** How `keepScroll` remembers and restores each history entry's offset. */
-export interface KeepScrollOptions {
-  /** The `sessionStorage` key holding entry offsets. Default `'foldkit:scroll'`. */
-  readonly storageKey?: string | undefined;
-  /** Entries remembered at most: the oldest are forgotten first. Default 50. */
-  readonly kept?: number | undefined;
-  /**
-   * How long a restore holds its place while the next screen settles, in
-   * milliseconds. Default 2000.
-   */
-  readonly patience?: number | undefined;
-}
-/**
- * Keeps the window's scroll across same-document navigations: a pushed entry
- * starts at the top, and Back, Forward or a reload return where that entry
- * was. Without a window the stream is empty instead of throwing. Lift with
- * `Subscription.persistentEntry`; the stream sends no Messages.
- */
-export declare const keepScroll: (options?: KeepScrollOptions) => Stream.Stream<never>;
-/**
- * The address of the link a reader points at or tabs to, on the page's own
- * origin: where they may go next, for a `Data.preload` before they go. Each
- * link once while they stay on it, since crossing its text sends one event
- * per element inside it. Without a document the stream is empty. Lift with
- * `Subscription.persistentEntry`, mapping each address to a Message.
- */
-export declare const pointedLinks: () => Stream.Stream<Url>;
-/** The custom properties `FluidHover` writes on its container for a highlight named `name`. */
-export declare const fluidHovered: (name: string) => {
-  readonly x: `--fk-${string}-x`;
-  readonly y: `--fk-${string}-y`;
-  readonly w: `--fk-${string}-w`;
-  readonly h: `--fk-${string}-h`;
-  /** `1` while an item is highlighted, `0` once the pointer and focus have left. */
-  readonly shown: `--fk-${string}-shown`;
-  /**
-   * `0` for the frame the highlight appears in, then `1`: a highlight's
-   * movement scales its duration by it, so it appears on its item rather
-   * than sliding in from where it last was.
-   */
-  readonly moving: `--fk-${string}-moving`;
-};
-/**
- * The attribute `FluidHover` sets on its container, to the highlight's name,
- * while it runs: a stylist draws the highlight, and drops each item's own
- * hover, only under it.
- */
-export declare const FLUID_HOVER_ATTRIBUTE = "data-fluid-hover";
-/** The attribute that names, inside an item, the control a press in a gap reaches. */
-export declare const FLUID_PRESS_ATTRIBUTE = "data-fluid-press";
-/** The attribute on the item the highlight is shown on, for what CSS draws beside it. */
-export declare const FLUID_LIT_ATTRIBUTE = "data-fluid-lit";
-/**
- * The attribute `FluidHover` sets on its container, to the highlight's name,
- * while the item that highlight is on is held. A stylist draws the press on
- * the highlight (`data-fluid-held`) rather than on the item, whose own press
- * is hidden under it; a press in a gap marks it too where `gapClick` sends
- * that press to the lit item.
- */
-export declare const FLUID_HELD_ATTRIBUTE = "data-fluid-held";
-declare const Axis: Schema.Literals<readonly ["x", "y", "xy"]>;
-export type FluidAxis = typeof Axis.Type;
-/**
- * One highlight that follows the pointer across a container's items, as a
- * Mount, with no Message and no Model: which item the pointer is nearest is
- * presentation, known to the DOM and to no transition.
- *
- * The item nearest the pointer is the one highlighted, so the pointer in a gap
- * between two items still points at one, and the highlight moves from item to
- * item instead of blinking off between them. On the `y` axis nearness is read
- * vertically (a list), on `x` horizontally (a strip), on `xy` both (a grid). A
- * disabled item (`aria-disabled="true"`, `data-disabled`, `:disabled`) is never
- * highlighted. An item reached by the keyboard (`:focus-visible`) is
- * highlighted too, and with `focused`, the item that selector finds from a
- * focused element that is no item (a tree's row, from its focused
- * `treeitem`, which also holds the rows beneath it); a touch highlights
- * nothing, since there is no pointer to
- * follow before the press.
- *
- * The container gets `--fk-<name>-x`, `-y`, `-w` and `-h` in pixels, relative
- * to its scroll box like `Measure`'s, and `-shown` and `-moving` (see
- * `fluidHovered`); a view draws the highlight as an absolutely placed child
- * that reads them. With `gapClick`, a click in a gap presses the highlighted
- * item: its descendant marked `data-fluid-press`, or the item itself; with
- * `gapReach` too, only a click within that many pixels of it, as a grid of
- * cards with wide gutters wants (Fluid Functionalism's uses 16). A popup
- * measured before it has a layout box keeps its last complete place, and
- * tries again for three frames, rather than drawing the highlight at zero.
- * The item the highlight is shown on carries `data-fluid-lit`, so a style
- * can change what sits beside it (a table hides the lines around the lit
- * row); its container carries `data-fluid-held` while that item is pressed.
- *
- * `follows` names the item the highlight sits on while the pointer is not
- * moving it: a menu marks the row its keys reach (`[data-active]`), and the
- * highlight goes there whenever that mark moves, so the keys and the pointer
- * light the same one. `from` names the item a fresh highlight grows out of,
- * as a tab's hover leaves the chosen tab. A highlight always fades where it
- * is: once the pointer leaves, nothing should move. It stays only for an item
- * the keyboard reached (`:focus-visible`), not one a click focused.
- */
-export declare const FluidHover: Mount.MountDefinitionWithArgs<"FluidHover", {
-  /** The highlight's name, which names the custom properties. */
-  name: Schema.String;
-  /** The selector of an item within the container. */
-  item: Schema.String;
-  axis: Schema.Literals<readonly ["x", "y", "xy"]>;
-  gapClick: Schema.Boolean;
-  /** How far from the highlighted item, in pixels, a click in a gap still presses it. */
-  gapReach: Schema.optional<Schema.Number>;
-  /** The selector of the item the highlight sits on while the pointer is not moving it. */
-  follows: Schema.optional<Schema.String>;
-  /** The selector of the item a fresh highlight grows out of. */
-  from: Schema.optional<Schema.String>;
-  /** The selector, run from a focused element outside any item, of the item it lights. */
-  focused: Schema.optional<Schema.String>;
-}, never>;
-/**
- * The custom property `KeyboardInset` writes on its element: how much of the layout
- * viewport's bottom the on-screen keyboard (or anything else the visual viewport leaves
- * out) covers, in pixels.
- */
-export declare const KEYBOARD_INSET = "--fk-keyboard-inset";
-/**
- * The part of the layout viewport's height below the visual viewport: what the on-screen
- * keyboard covers. Rounded down, since a fraction of a pixel of zoom is no keyboard.
- */
-export declare const keyboardInset: (view: {
-  readonly innerHeight: number;
-  readonly visualViewport: {
-    readonly height: number;
-    readonly offsetTop: number;
-  } | null;
-}) => number;
-/**
- * The on-screen keyboard's height as a Mount, with no Message and no Model: where it is
- * is the browser's. iOS Safari, and Chrome on Android unless the page asks otherwise,
- * leave the layout viewport as it is when the keyboard opens, so a panel fixed to the
- * screen keeps its height and its bottom under the keys. This writes `KEYBOARD_INSET` on
- * the element, from the visual viewport's size and scroll, for a style to pad or shrink by
- * (`var(--fk-keyboard-inset, 0px)`), and removes it when the element goes. Where there is
- * no visual viewport it writes nothing.
- */
-export declare const KeyboardInset: Mount.MountDefinitionWithArgs<"KeyboardInset", {}, never>;
-/**
- * The attribute that marks a bar beside a scroller `ScrollBars` runs on, set
- * to the axis it shows: `block` (the up-and-down bar) or `inline`.
- */
-export declare const SCROLL_BAR_ATTRIBUTE = "data-scroll-bar";
-/**
- * The attribute `ScrollBars` sets on its scroller while it draws the bars, so a
- * style hides the native bar only then: with no Mount running (a coarse
- * pointer, a page not yet hydrated) the browser's bar stays.
- */
-export declare const SCROLL_OVERLAID_ATTRIBUTE = "data-scroll-overlaid";
-/**
- * The custom properties `ScrollBars` writes on each bar, in pixels, for its
- * thumb to read: how far along the bar the thumb starts, and how long it is.
- * Physical: an inline bar's offset is from its left edge in either direction.
- */
-export declare const scrollThumb: {
-  readonly offset: '--fk-scroll-thumb-offset';
-  readonly size: '--fk-scroll-thumb-size';
-};
-/**
- * An overlay scrollbar as a Mount, with no Message and no Model: where a
- * scroller is scrolled is the browser's, and the bar only shows it.
- *
- * It runs on the scroller (or on an element holding it, named by `scroller`,
- * when the scroller carries another Mount) and drives the bars drawn beside
- * it: the scroller's parent's children marked `data-scroll-bar` (`block` or
- * `inline`), which a style lays over the scroller's edge. Each bar gets `data-scrollable` while its axis has
- * more to scroll, `data-shown` while the scroller scrolls or the pointer moves
- * over it, until `idle` milliseconds pass with neither (or longer, while the
- * pointer rests on a bar), and `data-dragging` while its thumb is dragged; and
- * `--fk-scroll-thumb-offset` and `-size` (see `scrollThumb`). Pressing a bar
- * off its thumb moves the thumb there, then drags it.
- *
- * It does nothing where the primary pointer is coarse or cannot hover, decided
- * when it mounts: touch keeps the browser's bar and its physics. Otherwise the
- * scroller gets `data-scroll-overlaid`, for a style to hide the native bar.
- * How the bar looks, rests, widens and fades is the style's.
- */
-export declare const ScrollBars: Mount.MountDefinitionWithArgs<"ScrollBars", {
-  /** How long, in milliseconds, the bars stay after the last scroll or move. Default 600. */
-  idle: Schema.optional<Schema.Number>;
-  /**
-   * The scroller, as a selector within the element, when it cannot hold this
-   * Mount itself (another component's, with a Mount of its own); looked for
-   * once, when it mounts. Default: the element is the scroller.
-   */
-  scroller: Schema.optional<Schema.String>;
-}, never>;
-export declare const SwipeStarted: Schema.TaggedStruct<"SwipeStarted", {
-  readonly pointerId: Schema.Number;
-  readonly pointerType: Schema.String;
-  /** The border box of what `measure` names (the element itself by default), as the swipe starts. */
-  readonly width: Schema.Number;
-  readonly height: Schema.Number;
-}>;
-export type SwipeStarted = typeof SwipeStarted.Type;
-export declare const Swiped: Schema.TaggedStruct<"Swiped", {
-  readonly pointerId: Schema.Number;
-  /** From where the pointer went down, in CSS pixels. */
-  readonly deltaX: Schema.Number;
-  readonly deltaY: Schema.Number;
-}>;
-export type Swiped = typeof Swiped.Type;
-export declare const SwipeEnded: Schema.TaggedStruct<"SwipeEnded", {
-  readonly pointerId: Schema.Number;
-  /** From where the pointer went down to where it came up, in CSS pixels. */
-  readonly deltaX: Schema.Number;
-  readonly deltaY: Schema.Number;
-  /**
-   * How fast the pointer was moving as it came up, in pixels a millisecond,
-   * over the last `SWIPE_WINDOW` milliseconds: 0 when it rested there first.
-   */
-  readonly velocityX: Schema.Number;
-  readonly velocityY: Schema.Number;
-  /** `false` when the pointer was cancelled or capture was lost. */
-  readonly completed: Schema.Boolean;
-}>;
-export type SwipeEnded = typeof SwipeEnded.Type;
-export type SwipeFact = SwipeStarted | Swiped | SwipeEnded;
-/** How far back, in milliseconds, the release velocity looks. */
-export declare const SWIPE_WINDOW = 100;
-/**
- * What a swipe never starts on when its element `scrolls`: a field whose own
- * drag selects text or moves a thumb, and anything marked `data-no-swipe`.
- */
-export declare const NO_SWIPE = "input, textarea, select, [contenteditable=\"\"], [contenteditable=\"true\"], [data-no-swipe]";
-interface Sample {
-  readonly at: number;
-  readonly x: number;
-  readonly y: number;
-}
-/**
- * The velocity of the samples within `SWIPE_WINDOW` of the last: the way
- * from the oldest of them to the last over the time between. A pointer that
- * came to rest before the last sample has no recent way to measure, so 0.
- */
-export declare const velocityOf: (samples: ReadonlyArray<Sample>) => {
-  x: number;
-  y: number;
-};
-/**
- * Whether anything from `target` up to `root` can still scroll along `axis`
- * the way a finger moving `along` (positive is down or right) pulls it: a
- * finger going down scrolls content toward its start.
- */
-export declare const canScroll: (target: Element, root: Element, axis: 'x' | 'y', along: number) => boolean;
-/**
- * `Move` with the speed of its release, for a gesture that a flick ends
- * (a sheet dragged to dismiss, a card swiped away): a primary-button pointer
- * down (or, given a `slop`, its first move past it) captures the pointer,
- * each move reports the delta from where it was pressed, and up reports the
- * last delta with the velocity over the last `SWIPE_WINDOW` milliseconds, by
- * the events' own time stamps. Cancel or lost capture ends it incomplete.
- * The start reports the size of what is moved, so a distance can be read as
- * a share of it. What a delta or a speed means is the parent's `update`.
- * Capture is released with the Mount.
- *
- * Given `scrolls`, the element holds content that scrolls (a sheet's panel),
- * and a touch is followed by touch events, whose move can still refuse the
- * browser's scroll once the touch is under way, where a pointer's cannot:
- * past the slop, a touch that runs along the axis and finds nothing under it
- * that can scroll further its way swipes, and the browser scrolls any other.
- * A touch inside an element with a Swipe of its own (a handle in the panel)
- * is that one's, and none starts on a field or on `data-no-swipe`
- * (`NO_SWIPE`).
- */
-export declare const Swipe: Mount.MountDefinitionWithArgs<"Swipe", {
-  /**
-   * The nearest ancestor matching this selector is measured as the swipe
-   * starts, for what the swipe moves (a sheet's panel, dragged by its
-   * handle). Default: the element itself.
-   */
-  measure: Schema.optional<Schema.String>;
-  /**
-   * How far, in pixels, a press must move before it is a swipe. Until
-   * then nothing is captured or reported, so a press that stays put is
-   * still a click on whatever is under it (a tab inside a drag grip).
-   * Default 0: the press itself starts the swipe; with `scrolls`, the
-   * first move decides.
-   */
-  slop: Schema.optional<Schema.Number>;
-  /** The axis the element's content scrolls along, which a touch yields to; see above. */
-  scrolls: Schema.optional<Schema.Literals<readonly ["x", "y"]>>;
-  /** Follows touches alone: a mouse or a pen is left to the page (and to a handle's own Swipe). */
-  touchOnly: Schema.optional<Schema.Boolean>;
-}, {
-  readonly _tag: "SwipeStarted";
-  readonly pointerId: number;
-  readonly pointerType: string;
-  readonly width: number;
-  readonly height: number;
-} | {
-  readonly _tag: "Swiped";
-  readonly pointerId: number;
-  readonly deltaX: number;
-  readonly deltaY: number;
-} | {
-  readonly _tag: "SwipeEnded";
-  readonly pointerId: number;
-  readonly deltaX: number;
-  readonly deltaY: number;
-  readonly velocityX: number;
-  readonly velocityY: number;
-  readonly completed: boolean;
-}>;
-export declare const ScrollSettled: Schema.TaggedStruct<"ScrollSettled", {
-  /** The item whose start lies nearest the scroller's start, from 0. */
-  readonly index: Schema.Number;
-}>;
-export type ScrollSettled = typeof ScrollSettled.Type;
-/** How long a scroll must be still to count as settled, where `scrollend` is missing. */
-export declare const SETTLE_QUIET = 120;
-/**
- * Hears a scroller come to rest, as a Mount: after a swipe, a fling, a
- * trackpad or a scroll a Command made, it reports which of its items starts
- * nearest its own start (inside its `scroll-padding`), the start being the
- * right edge right to left. A snapping carousel reads it as the slide shown.
- *
- * At insert it first scrolls, at once, to item `start` (the Mount's args are
- * read only then, so this is where a redrawn or restored scroller begins),
- * and reports where it lies, since a scroller drawn already at rest sends no
- * `scrollend`. It listens for `scrollend` where the browser has it, and
- * otherwise for a scroll that is quiet for `SETTLE_QUIET` milliseconds.
- */
-export declare const ScrollSettle: Mount.MountDefinitionWithArgs<"ScrollSettle", {
-  /** Which children are the items; default every child. */
-  item: Schema.optional<Schema.String>;
-  /** Default `inline`, the row a carousel scrolls along. */
-  axis: Schema.optional<Schema.Literals<readonly ["inline", "block"]>>;
-  /** The item to scroll to at insert; default the first, which needs no scroll. */
-  start: Schema.optional<Schema.Number>;
-}, {
-  readonly _tag: "ScrollSettled";
-  readonly index: number;
-}>;
-/**
- * A place in an element's padding box, in CSS pixels from its top left
- * corner, and the pointer's pressure there (0 to 1; a mouse reads 0.5 while
- * a button is down). A captured pointer can be outside the box, so `x` and
- * `y` can be negative or past its size.
- */
-export declare const PointerPoint: Schema.Struct<{
-  readonly x: Schema.Number;
-  readonly y: Schema.Number;
-  readonly pressure: Schema.Number;
-}>;
-export type PointerPoint = typeof PointerPoint.Type;
-export declare const PointerPressed: Schema.TaggedStruct<"PointerPressed", {
-  readonly width: Schema.Number;
-  readonly height: Schema.Number;
-  readonly point: Schema.Struct<{
-    readonly x: Schema.Number;
-    readonly y: Schema.Number;
-    readonly pressure: Schema.Number;
-  }>;
-  /** `mouse`, `pen` or `touch`, as the browser names it. */
-  readonly pointerType: Schema.String;
-}>;
-export type PointerPressed = typeof PointerPressed.Type;
-export declare const PointerMoved: Schema.TaggedStruct<"PointerMoved", {
-  readonly width: Schema.Number;
-  readonly height: Schema.Number;
-  /** Where the pointer is now. */
-  readonly point: Schema.Struct<{
-    readonly x: Schema.Number;
-    readonly y: Schema.Number;
-    readonly pressure: Schema.Number;
-  }>;
-  /**
-   * Every place it passed since the last move, ending with `point`: the
-   * browser's coalesced events, so a fast stroke keeps its curve. Just
-   * `point` where the browser coalesces none.
-   */
-  readonly points: Schema.$Array<Schema.Struct<{
-    readonly x: Schema.Number;
-    readonly y: Schema.Number;
-    readonly pressure: Schema.Number;
-  }>>;
-}>;
-export type PointerMoved = typeof PointerMoved.Type;
-export declare const PointerReleased: Schema.TaggedStruct<"PointerReleased", {
-  /** `false` when the pointer was cancelled, lost its capture, or pressed again unreleased. */
-  readonly completed: Schema.Boolean;
-}>;
-export type PointerReleased = typeof PointerReleased.Type;
-export type PointerFact = PointerPressed | PointerMoved | PointerReleased;
-interface Sides {
-  readonly top: number;
-  readonly right: number;
-  readonly bottom: number;
-  readonly left: number;
-}
-export interface Rect {
-  readonly left: number;
-  readonly top: number;
-  readonly width: number;
-  readonly height: number;
-}
-/**
- * The padding box of an element whose border box is `rect`: inside its
- * border, padding included. An absolutely positioned child (a thumb, a
- * stroke) is laid out against it, so a place read here is where that child
- * sits, whatever padding a stylist adds.
- */
-export declare const paddingBoxOf: (layout: {
-  readonly rect: Rect;
-  readonly border: Sides;
-}) => Rect;
-/**
- * An element's padding box now, in the viewport, as `PointerPosition`
- * measures it: for a size kept beside its places, which a `ResizeObserver`'s
- * content box does not match once the element has padding. Read from the
- * bounding rectangle and the computed border, since `clientWidth` and
- * `clientLeft` round to whole pixels.
- */
-export declare const measurePaddingBox: (element: Element) => Rect;
-/**
- * Where one pointer is inside an element, as a Mount, for a surface the
- * pointer draws on or points into (a color area, a dial, a signature pad): a
- * primary press, each move until the release, and the release, each with
- * the place in the element's padding box and the box's size. The box is
- * measured at each event, so an element that moved or resized is followed.
- * Coordinates are raw, left to right and top down whatever the direction:
- * what a place means (a share, an angle, a reading direction) is the parent's.
- *
- * The pointer is captured from press to release, so a drag that leaves the
- * element is still heard, and the moves and the release are listened to only
- * meanwhile. A press keeps the browser's own focus and text selection away,
- * and a second pointer while one is down is ignored.
- */
-export declare const PointerPosition: Mount.MountDefinitionWithArgs<"PointerPosition", {
-  /**
-   * A descendant to focus on a press, found by this selector (a thumb), so
-   * the keys go on from where the pointer left it.
-   */
-  focus: Schema.optionalKey<Schema.String>;
-}, {
-  readonly _tag: "PointerPressed";
-  readonly width: number;
-  readonly height: number;
-  readonly point: {
-    readonly x: number;
-    readonly y: number;
-    readonly pressure: number;
-  };
-  readonly pointerType: string;
-} | {
-  readonly _tag: "PointerMoved";
-  readonly width: number;
-  readonly height: number;
-  readonly point: {
-    readonly x: number;
-    readonly y: number;
-    readonly pressure: number;
-  };
-  readonly points: readonly {
-    readonly x: number;
-    readonly y: number;
-    readonly pressure: number;
-  }[];
-} | {
-  readonly _tag: "PointerReleased";
-  readonly completed: boolean;
-}>;
-/** The attribute on the mounted element naming the element `TrackBox` follows, by id. */
-export declare const TRACK_TARGET_ATTRIBUTE = "data-target";
-/** The custom properties `TrackBox` writes for `name`, as `measured` names `Measure`'s. */
-export declare const trackedBox: (name: string) => {
-  readonly x: `--fk-${string}-x`;
-  readonly y: `--fk-${string}-y`;
-  readonly w: `--fk-${string}-w`;
-  readonly h: `--fk-${string}-h`;
-  readonly radius: `--fk-${string}-radius`;
-};
-/** Sent as the followed element changes: its id, and whether it is on the page. */
-export declare const TrackedTarget: Schema.TaggedStruct<"TrackedTarget", {
-  readonly target: Schema.String;
-  readonly found: Schema.Boolean;
-}>;
-export type TrackedTarget = typeof TrackedTarget.Type;
-/**
- * The radius a box of `width` by `height` draws for a computed
- * `border-top-left-radius` of `value` (`8px`, `50%`, `8px 4px`): its
- * horizontal length in pixels, a share of the width for a percentage, and
- * never more than half the shorter side, where the browser stops it.
- */
-export declare const cornerRadius: (value: string, width: number, height: number) => number;
-/**
- * Follows another element's box, as a Mount: the element whose id is the
- * mounted element's `data-target` (`TRACK_TARGET_ATTRIBUTE`). Its box in
- * viewport pixels is written on the mounted element as `--fk-<name>-x`,
- * `-y`, `-w` and `-h`, and with `radius`, its top left corner's radius as
- * `--fk-<name>-radius` (`cornerRadius`), so a fixed overlay drawn from them
- * (a tour's cutout, a coach mark's ring) sits over it. While nothing is
- * followed they are removed, so a stylist's fallbacks apply.
- *
- * The box is read again on a scroll anywhere (heard on the way down, since
- * `scroll` does not bubble), a window resize, the followed element's own
- * resize, and any change to the document's elements, which is also how a
- * target drawn anew under the same id is found. `data-target` is read again
- * whenever it changes, so one element can glide from target to target
- * without being drawn again, which a Mount's args, read once, could not do.
- * What moves the target by any other way (a stylesheet added) is seen at the
- * next of these.
- *
- * Whether a target is on the page is the parent's to act on (a tour shows
- * the step in the middle instead), so each change of the target or of
- * whether it is found sends `TrackedTarget`, starting with the first one.
- * Since it sends a Message, a component may draw it by default: a Scene test
- * resolves it with what the parent maps it to. An empty `data-target` follows
- * nothing and sends nothing.
- */
-export declare const TrackBox: Mount.MountDefinitionWithArgs<"TrackBox", {
-  /** The custom properties' prefix: `tour` writes `--fk-tour-x`. */
-  name: Schema.String;
-  /** Whether to write the target's corner radius too; it reads the target's computed style. */
-  radius: Schema.optional<Schema.Boolean>;
-}, {
-  readonly _tag: "TrackedTarget";
-  readonly target: string;
-  readonly found: boolean;
-}>;
-export declare const ImageDecodeMessage: import("foldkit/message").MessageUnion<{
-  readonly Decoded: {
-    src: Schema.String;
-  };
-  readonly DecodeFailed: {
-    src: Schema.String;
-    message: Schema.String;
-  };
-}>;
-export type ImageDecodeMessage = typeof ImageDecodeMessage.Type;
-/** What to decode: a URL, or an `img`'s candidates, so the browser decodes the one it would draw. */
-export interface ImageSource {
-  readonly src: string;
-  readonly srcset?: string | undefined;
-  readonly sizes?: string | undefined;
-}
-/**
- * Fetches and decodes `source` (`img.decode()`), yielding `Decoded` once it
- * can be painted at once, or `DecodeFailed` when it cannot be fetched or read,
- * or there is no document (a server render). Given `srcset` and `sizes`, as
- * `foldkit-media`'s `Picture.Img` has them, the browser picks the candidate
- * it would draw, so the decoded file is the one shown.
- */
-export declare const decodeImage: (source: ImageSource) => Command<ImageDecodeMessage, never, never>;
-export { DRAG_THRESHOLD, DragCancelled, DragDropped, DragFact, DragPlace, DragStarted, DragZone, DraggedOver, EditAsked, EditableText, Fact, FocusScope, HOLD_SLOP, HOLD_TO_DRAG_MS, HideOutside, Move, MoveEnded, MoveStarted, Moved, PointerDrag, ScrollLock, TargetFact, TargetHovered, TargetPressed, Targets, TextCancelled, TextCommitted, TextEdited, TextFact, boxOf, tabbableWithin, targetOf, textOf, zoneOf };
-//# sourceMappingURL=index.d.mts.map