foldkit-primitives 0.10.2 → 0.12.0

package/dist/dom/index.d.mts

@@ -1,4 +1,4 @@
-import { A as ScrollLock, C as targetOf, D as MoveStarted, E as MoveEnded, M as tabbableWithin, O as Moved, S as Targets, T as Move, _ as boxOf, a as TextEdited, b as TargetHovered, c as DRAG_THRESHOLD, d as DragFact, f as DragPlace, g as PointerDrag, h as DraggedOver, i as TextCommitted, j as FocusScope, k as HideOutside, 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 zoneOf, w as Fact, x as TargetPressed, y as TargetFact } from "../editable-text-Dvm-Fuqs.mjs";
+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-1D31qthY.mjs";
 import { Schema, Stream } from "effect";
 import * as Mount from "foldkit/mount";
 import { Url } from "foldkit/url";
@@ -199,5 +199,472 @@ export declare const keepScroll: (options?: KeepScrollOptions) => Stream.Stream<
  */
 export declare const pointedLinks: () => Stream.Stream<Url>;
 //#endregion
-export { DRAG_THRESHOLD, DragCancelled, DragDropped, DragFact, DragPlace, DragStarted, DragZone, DraggedOver, EditAsked, EditableText, Fact, FocusScope, HideOutside, Move, MoveEnded, MoveStarted, Moved, PointerDrag, ScrollLock, TargetFact, TargetHovered, TargetPressed, Targets, TextCancelled, TextCommitted, TextEdited, TextFact, boxOf, tabbableWithin, targetOf, textOf, zoneOf };
+//#region src/dom/fluid-hover.d.ts
+/** 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";
+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; 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).
+ *
+ * `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>;
+}, never>;
+//#endregion
+//#region src/dom/keyboard-inset.d.ts
+/**
+ * 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>;
+//#endregion
+//#region src/dom/scroll-bars.d.ts
+/**
+ * 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>;
+//#endregion
+//#region src/dom/swipe.d.ts
+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;
+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;
+};
+/**
+ * `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 captures the pointer, each move reports the delta from where it
+ * started, 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.
+ */
+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>;
+}, {
+  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;
+}>;
+//#endregion
+//#region src/dom/scroll-settle.d.ts
+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;
+}>;
+//#endregion
+//#region src/dom/pointer-position.d.ts
+/**
+ * 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;
+}>;
+//#endregion
+//#region src/dom/track-box.d.ts
+/** 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;
+}>;
+//#endregion
+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

package/dist/dom/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/keep-in-view.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts","../../src/dom/measure.ts","../../src/dom/follow-tab-stop.ts","../../src/dom/scroll.ts","../../src/dom/pointed-links.ts"],"mappings":";;;;;;qBAGa,SAAO,OAAA;YACR,iBAAiB,QAAQ;;;;;;;;qBASxB,WAAS,MAAA;;;;;qBCJT,4CAAgB;;;IAEb,SAAO,OAAA;;;YAEX,0BAA0B,iBAAiB;qBAE1C,gDAAoB;;IACvB,MAAI,OAAA;;;IACE,SAAO,OAAA;;;YAEX,8BAA8B,qBAAqB;;;;;;qBAUlD,WAAQ,iBAAmB,QAAQ;;;;;qBAsBnC,gBAAe,QAAQ;;;;qBC/CvB,OAAK,OAAA;;;;YAIN,eAAe,MAAM;;;;;;;qBAiCpB,YAAS,eACP;WAED;WAAyB;;;;;;;;;;;qBA6C1B,WAAS,MAAA;WAAT,OAAA;;;;;;;;;;;;;;;;;qBC7EA,YAAU,MAAA;;YAAV,OAAA;;;;qBCDA,yCAAa;;;IAEV,SAAO,OAAA;;;YAEX,uBAAuB,cAAc;;qBASpC,aAAU,gBAAkB,QAAQ;;;qBCbpC,WAAS,OAAA;;;;;YAKV,mBAAmB,UAAU;qBAE5B,wCAAY;;;;IAGR,SAAO,OAAA;;;YAEZ,sBAAsB,aAAa;;qBAUlC,QAAK,MAAU,cAAY,QAAQ;;;;qBC7BnC,WAAQ;WAEjB;WACA;WACA;WACA;WACA;;;;;;;;;;;;;;;;;;;;;qBAsBS,SAAO,MAAA;;;;;;;;;;;;;;qBCrBP,eAAa,MAAA;;;;iBCuBT;;WAEN;;WAEA;;;;;WAKA;;;;;;;;qBAuHE,aAAU,UAAa,sBAAyB,OAAO;;;;;;;;;;qBCvJvD,oBAAmB,OAAO,OAAO"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/keep-in-view.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts","../../src/dom/measure.ts","../../src/dom/follow-tab-stop.ts","../../src/dom/scroll.ts","../../src/dom/pointed-links.ts","../../src/dom/fluid-hover.ts","../../src/dom/keyboard-inset.ts","../../src/dom/scroll-bars.ts","../../src/dom/swipe.ts","../../src/dom/scroll-settle.ts","../../src/dom/pointer-position.ts","../../src/dom/track-box.ts"],"mappings":"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"}