foldkit-primitives 0.15.3 → 0.16.0

package/dist/editable-text-1D31qthY.d.mts

@@ -1,319 +0,0 @@
-import { Schema } from "effect";
-import * as Mount from "foldkit/mount";
-//#region src/dom/focus-scope.d.ts
-/** Tabbable descendants in DOM order: focusable, visible, and not `tabindex="-1"`. */
-declare const tabbableWithin: (root: Element) => ReadonlyArray<HTMLElement>;
-/**
- * A focus scope as a Mount: on insert it remembers what was focused, focuses
- * an initial element inside, and with `contain` keeps Tab and Shift+Tab
- * cycling inside; on unmount it gives focus back. Nothing crosses to the
- * Model: which element had focus is a DOM fact, so this is element lifecycle,
- * not state. It emits no Messages.
- */
-declare const FocusScope: Mount.MountDefinitionWithArgs<"FocusScope", {
-  /** Keep Tab, Shift+Tab, and a stray focus inside. */
-  contain: Schema.Boolean;
-  /** Give focus back to what had it, on unmount. */
-  restore: Schema.Boolean;
-  /** A selector inside the element to focus first; else the first tabbable
-   *  descendant, else the element itself when it is focusable. */
-  initialFocus: Schema.NullOr<Schema.String>;
-}, never>;
-//#endregion
-//#region src/dom/layers.d.ts
-/** Locks the document's scroll while the element is mounted; nested locks release with the last. */
-declare const ScrollLock: Mount.MountDefinitionNoArgs<"ScrollLock", never>;
-/** Makes everything outside the element inert while it is mounted, and restores it after. */
-declare const HideOutside: Mount.MountDefinitionNoArgs<"HideOutside", never>;
-//#endregion
-//#region src/dom/move.d.ts
-declare const MoveStarted: Schema.TaggedStruct<"MoveStarted", {
-  readonly pointerId: Schema.Number;
-  readonly pointerType: Schema.String;
-}>;
-type MoveStarted = typeof MoveStarted.Type;
-declare const Moved: Schema.TaggedStruct<"Moved", {
-  readonly pointerId: Schema.Number;
-  /** From where the pointer went down, in CSS pixels. */
-  readonly deltaX: Schema.Number;
-  readonly deltaY: Schema.Number;
-  readonly pointerType: Schema.String;
-}>;
-type Moved = typeof Moved.Type;
-declare const MoveEnded: Schema.TaggedStruct<"MoveEnded", {
-  readonly pointerId: Schema.Number;
-  /** `false` when the pointer was cancelled or capture was lost. */
-  readonly completed: Schema.Boolean;
-}>;
-type MoveEnded = typeof MoveEnded.Type;
-type Fact = MoveStarted | Moved | MoveEnded;
-/**
- * Pointer movement on an element as a Mount: a primary-button pointer down
- * captures the pointer, each move reports the delta from where it started,
- * and up, cancel, or lost capture ends it. Nothing is decided here: a drag
- * threshold, a snap, or a constraint is the parent's `update`. Capture is
- * released with the Mount.
- */
-declare const Move: Mount.MountDefinitionNoArgs<"Move", {
-  readonly _tag: "MoveStarted";
-  readonly pointerId: number;
-  readonly pointerType: string;
-} | {
-  readonly _tag: "Moved";
-  readonly pointerId: number;
-  readonly deltaX: number;
-  readonly deltaY: number;
-  readonly pointerType: string;
-} | {
-  readonly _tag: "MoveEnded";
-  readonly pointerId: number;
-  readonly completed: boolean;
-}>;
-//#endregion
-//#region src/dom/targets.d.ts
-declare const TargetHovered: Schema.TaggedStruct<"TargetHovered", {
-  /** The marked descendant under the pointer, or `null` when there is none. */
-  readonly id: Schema.NullOr<Schema.String>;
-}>;
-type TargetHovered = typeof TargetHovered.Type;
-declare const TargetPressed: Schema.TaggedStruct<"TargetPressed", {
-  readonly id: Schema.String;
-  readonly shiftKey: Schema.Boolean;
-  readonly altKey: Schema.Boolean;
-  readonly ctrlKey: Schema.Boolean;
-  readonly metaKey: Schema.Boolean;
-}>;
-type TargetPressed = typeof TargetPressed.Type;
-type TargetFact = TargetHovered | TargetPressed;
-/** The id of the nearest marked element at or above `from`, inside `container`. */
-declare const targetOf: (container: Element, from: EventTarget | null, attribute: string) => string | null;
-/**
- * Which marked descendant of an element the pointer is over, and which one was
- * pressed, as a Mount: one set of listeners on the container, not one per item.
- * A descendant is marked by an attribute whose value is its id, such as a
- * canvas's `data-composition-node` or a table's `data-row`. The nearest marked
- * ancestor of the event's target, inside the container, is the one reported.
- *
- * What hovering or pressing means (a selection, an outline, a menu) is the
- * parent's `update`.
- */
-declare const Targets: Mount.MountDefinitionWithArgs<"Targets", {
-  /** The attribute that marks a descendant, holding its id. */
-  attribute: Schema.String;
-  /** Prevent a press's default, such as a link navigating inside an editor's canvas. */
-  preventDefault: Schema.Boolean;
-}, {
-  readonly _tag: "TargetHovered";
-  readonly id: string | null;
-} | {
-  readonly _tag: "TargetPressed";
-  readonly id: string;
-  readonly shiftKey: boolean;
-  readonly altKey: boolean;
-  readonly ctrlKey: boolean;
-  readonly metaKey: boolean;
-}>;
-//#endregion
-//#region src/dom/pointer-drag.d.ts
-declare const DragZone: Schema.Literals<readonly ["before", "inside", "after"]>;
-type DragZone = typeof DragZone.Type;
-/**
- * A marked descendant under the pointer, and the zone of it the pointer is in.
- * `part` is the value of the `part` attribute on the element found, such as
- * the empty Region of a node a drop goes into; a place with one is `inside`.
- */
-declare const DragPlace: Schema.Struct<{
-  readonly id: Schema.String;
-  readonly zone: Schema.Literals<readonly ["before", "inside", "after"]>;
-  readonly part: Schema.optionalKey<Schema.String>;
-}>;
-type DragPlace = typeof DragPlace.Type;
-declare const DragStarted: Schema.TaggedStruct<"DragStarted", {
-  /** The marked descendant being dragged. */
-  readonly id: Schema.String;
-}>;
-type DragStarted = typeof DragStarted.Type;
-declare const DraggedOver: Schema.TaggedStruct<"DraggedOver", {
-  /** Where the pointer is, or `null` over nothing marked, or over what is dragged. */
-  readonly over: Schema.NullOr<Schema.Struct<{
-    readonly id: Schema.String;
-    readonly zone: Schema.Literals<readonly ["before", "inside", "after"]>;
-    readonly part: Schema.optionalKey<Schema.String>;
-  }>>;
-  /**
-   * For a drag onto `targets`: whether the pointer is inside the region they
-   * are in, so `over: null` with `region: true` is its empty space (an empty
-   * page, the space below the last node). Absent for a drag among its own.
-   */
-  readonly region: Schema.optionalKey<Schema.Boolean>;
-}>;
-type DraggedOver = typeof DraggedOver.Type;
-declare const DragDropped: Schema.TaggedStruct<"DragDropped", {
-  readonly id: Schema.String;
-  readonly over: Schema.NullOr<Schema.Struct<{
-    readonly id: Schema.String;
-    readonly zone: Schema.Literals<readonly ["before", "inside", "after"]>;
-    readonly part: Schema.optionalKey<Schema.String>;
-  }>>;
-  /** As `DraggedOver`'s: released inside the `targets` region. */
-  readonly region: Schema.optionalKey<Schema.Boolean>;
-}>;
-type DragDropped = typeof DragDropped.Type;
-declare const DragCancelled: Schema.TaggedStruct<"DragCancelled", {
-  readonly id: Schema.String;
-}>;
-type DragCancelled = typeof DragCancelled.Type;
-type DragFact = DragStarted | DraggedOver | DragDropped | DragCancelled;
-/** How far, in CSS pixels, a press moves before it is a drag rather than a click. */
-declare const DRAG_THRESHOLD = 4;
-/**
- * How long a finger is held still before its press is a drag. A touch that moves first is a
- * scroll, so a list of draggable rows still scrolls under a finger.
- */
-declare const HOLD_TO_DRAG_MS = 400;
-/** How far, in CSS pixels, a held finger may wander before the hold is a scroll. */
-declare const HOLD_SLOP = 8;
-interface Box {
-  readonly top: number;
-  readonly height: number;
-}
-/** The zone of a box a vertical position falls in, by thirds. */
-declare const zoneOf: (box: Box, y: number) => DragZone;
-/**
- * An element's box. An element drawn as `display: contents` has none, so its
- * first child's stands for it, as an editor's node wrapper's does.
- */
-declare const boxOf: (element: Element) => Box;
-/**
- * Dragging one marked descendant of an element onto another, as a Mount. A
- * descendant is marked by an attribute whose value is its id, as `Targets`
- * marks them; a press on one that then moves past a threshold starts a drag (a
- * finger's, held still for `HOLD_TO_DRAG_MS`, as a touch that moves first scrolls), and
- * the pointer's place over another marked descendant is reported with the
- * zone of it the pointer is in: its first third (`before`), its middle
- * (`inside`), or its last third (`after`). Releasing drops, and Escape or a
- * cancelled pointer ends the drag with nothing dropped.
- *
- * It writes no roles, no `tabindex` and no key handling, so the marked
- * elements can be anything: a tree's rows, a canvas's nodes. The keyboard's way
- * to do what a drag does is the parent's to give. Geometry is measured when the
- * pointer moves and never kept; what a drop means is the parent's `update`.
- */
-declare const PointerDrag: Mount.MountDefinitionWithArgs<"PointerDrag", {
-  /** The attribute that marks a descendant, holding its id. */
-  attribute: Schema.String;
-  /**
-   * Where a drag may land, when not on the element's own marked descendants:
-   * the elements marked by `attribute` inside the one `within` selects, such
-   * as a palette's Blocks dragged onto a page. A drop's `over` is then one of
-   * those; what is dragged is still one of the element's own. `within` is
-   * looked for nearest first, under the element's closest ancestor that holds
-   * a match, so two editors on one page each drop onto their own.
-   */
-  targets: Schema.optionalKey<Schema.Struct<{
-    readonly attribute: Schema.String;
-    readonly within: Schema.String;
-  }>>;
-  /**
-   * An attribute that names a part of what a drop lands on, on an element
-   * also marked as one: a place over it carries the part and is `inside`.
-   */
-  part: Schema.optionalKey<Schema.String>;
-}, {
-  readonly _tag: "DragStarted";
-  readonly id: string;
-} | {
-  readonly _tag: "DraggedOver";
-  readonly over: {
-    readonly id: string;
-    readonly zone: "after" | "before" | "inside";
-    readonly part?: string;
-  } | null;
-  readonly region?: boolean;
-} | {
-  readonly _tag: "DragDropped";
-  readonly id: string;
-  readonly over: {
-    readonly id: string;
-    readonly zone: "after" | "before" | "inside";
-    readonly part?: string;
-  } | null;
-  readonly region?: boolean;
-} | {
-  readonly _tag: "DragCancelled";
-  readonly id: string;
-}>;
-//#endregion
-//#region src/dom/editable-text.d.ts
-declare const TextEdited: Schema.TaggedStruct<"TextEdited", {
-  /** The field, by its marking attribute's value. */
-  readonly field: Schema.String;
-  readonly text: Schema.String;
-}>;
-type TextEdited = typeof TextEdited.Type;
-declare const TextCommitted: Schema.TaggedStruct<"TextCommitted", {
-  readonly field: Schema.String;
-  readonly text: Schema.String;
-}>;
-type TextCommitted = typeof TextCommitted.Type;
-declare const TextCancelled: Schema.TaggedStruct<"TextCancelled", {
-  readonly field: Schema.String;
-  /** The text the field had when editing began, which the DOM shows again. */
-  readonly initial: Schema.String;
-}>;
-type TextCancelled = typeof TextCancelled.Type;
-declare const EditAsked: Schema.TaggedStruct<"EditAsked", {
-  /** A marked field, not editable yet, that was double-clicked. */
-  readonly field: Schema.String;
-}>;
-type EditAsked = typeof EditAsked.Type;
-type TextFact = TextEdited | TextCommitted | TextCancelled | EditAsked;
-/**
- * A field's text. A browser ends an edited element with a line break it adds
- * itself, which is not the author's; in one line, the author's breaks are spaces.
- */
-declare const textOf: (element: HTMLElement) => string;
-/**
- * Text typed into an editable descendant of an element, as a Mount: one set of
- * listeners on the container, like `Targets`. A field is a descendant marked
- * by an attribute whose value names it, while it is `contenteditable`. The
- * view decides which one is; the Mount focuses it as it becomes so (made
- * editable, or drawn editable), with the caret at its end, and at no other
- * time. When Enter or Escape ends an edit and the view then removes the field
- * or makes it no longer editable, focus, left on nothing, comes back to the
- * container, so the next key reaches it; give the container a `tabindex`. A double-click on a marked field that is not editable yet asks for it
- * to be (`EditAsked`).
- *
- * It reads `innerText`, never `innerHTML`, so what arrives is text. A field is
- * one line unless it carries `aria-multiline="true"`: in one line, a line
- * break becomes a space. Nothing is reported while an input method composes;
- * the composed text arrives once, when it is done.
- *
- * Enter commits (Shift+Enter breaks a line in a multiline field), and so does
- * leaving the field. Escape cancels, and puts the text the field had when
- * editing began back in the DOM, since a view that stopped redrawing the field
- * while it was edited will not. Where the browser lacks `plaintext-only`, a
- * paste is inserted as text. What an edit means is the parent's `update`.
- */
-declare const EditableText: Mount.MountDefinitionWithArgs<"EditableText", {
-  /** The attribute that marks a field, holding its name. */
-  attribute: Schema.String;
-}, {
-  readonly _tag: "TextEdited";
-  readonly field: string;
-  readonly text: string;
-} | {
-  readonly _tag: "TextCommitted";
-  readonly field: string;
-  readonly text: string;
-} | {
-  readonly _tag: "TextCancelled";
-  readonly field: string;
-  readonly initial: string;
-} | {
-  readonly _tag: "EditAsked";
-  readonly field: string;
-}>;
-//#endregion
-export { Moved as A, TargetPressed as C, Move as D, Fact as E, ScrollLock as M, FocusScope as N, MoveEnded as O, tabbableWithin as P, TargetHovered as S, targetOf as T, HOLD_TO_DRAG_MS as _, TextEdited as a, zoneOf as b, DRAG_THRESHOLD as c, DragFact as d, DragPlace as f, HOLD_SLOP as g, DraggedOver as h, TextCommitted as i, HideOutside as j, MoveStarted as k, DragCancelled as l, DragZone as m, EditableText as n, TextFact as o, DragStarted as p, TextCancelled as r, textOf as s, EditAsked as t, DragDropped as u, PointerDrag as v, Targets as w, TargetFact as x, boxOf as y };
-//# sourceMappingURL=editable-text-1D31qthY.d.mts.map

package/dist/editable-text-1D31qthY.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"editable-text-1D31qthY.d.mts","names":[],"sources":["../src/dom/focus-scope.ts","../src/dom/layers.ts","../src/dom/move.ts","../src/dom/targets.ts","../src/dom/pointer-drag.ts","../src/dom/editable-text.ts"],"mappings":";;;;cAmBa,iBAAc,MAAU,YAAU,cAAc;;;;;;;;cAmBhD,YAAU,MAAA;;;;;;;;;;;;cCtBV,YAAU,MAAA;;cAWV,aAAW,MAAA;;;cCxBX,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;cAEhC,OAAK,OAAA;;;;;;;KAON,eAAe,MAAM;cAEpB,WAAS,OAAA;;;;;KAKV,mBAAmB,UAAU;KAE7B,OAAO,cAAc,QAAQ;;;;;;;;cAsB5B,MAAI,MAAA;;;;;;;;;;;;;;;;;cC5CJ,eAAa,OAAA;;;;KAId,uBAAuB,cAAc;cAEpC,eAAa,OAAA;;;;;;;KAOd,uBAAuB,cAAc;KAErC,aAAa,gBAAgB;;cAU5B,WAAQ,WAAe,SAAO,MAAQ,oBAAkB;;;;;;;;;;;cAgBxD,SAAO,MAAA;;;;;;;;;;;;;;;;;;cCxCP,UAAQ,OAAA;KACT,kBAAkB,SAAS;;;;;;cAO1B,WAAS,OAAA;;;;;KAKV,mBAAmB,UAAU;cAE5B,aAAW,OAAA;;eAAX,OAAA;;KAID,qBAAqB,YAAY;cAEhC,aAAW,OAAA;;;;;;;;;;;;;;KAUZ,qBAAqB,YAAY;cAEhC,aAAW,OAAA;;;;;;;;;;KAMZ,qBAAqB,YAAY;cAEhC,eAAa,OAAA;eAAb,OAAA;;KACD,uBAAuB,cAAc;KAErC,WAAW,cAAc,cAAc,cAAc;;cAGpD;;;;;cAMA;;cAGA;UAEH;WACC;WACA;;;cAIE,SAAM,KAAS,KAAG,cAAc;;;;;cAUhC,QAAK,SAAa,YAAU;;;;;;;;;;;;;;;;cAgC5B,aAAW,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC3GX,YAAU,OAAA;;;;;KAKX,oBAAoB,WAAW;cAE9B,eAAa,OAAA;;;;KAId,uBAAuB,cAAc;cAEpC,eAAa,OAAA;;;;;KAKd,uBAAuB,cAAc;cAEpC,WAAS,OAAA;;kBAAT,OAAA;;KAID,mBAAmB,UAAU;KAE7B,WAAW,aAAa,gBAAgB,gBAAgB;;;;;cASvD,SAAM,SAAa;;;;;;;;;;;;;;;;;;;;;;;cA0CnB,cAAY,MAAA;;aAAZ,OAAA"}

package/dist/events/index.d.mts

@@ -1,184 +0,0 @@
-import { a as modalityOfKey, i as Modality, n as InputModalityMessage, r as InputModalityModel, t as InputModality } from "../input-modality-BY-bSrEc.mjs";
-import { Schema, Stream } from "effect";
-import { Bundle } from "foldkit-bundle";
-//#region src/events/active-element.d.ts
-export declare const ActiveElementMessage: import("foldkit/message").MessageUnion<{
-  readonly Changed: {
-    tag: Schema.String;
-    id: Schema.NullOr<Schema.String>;
-  };
-}>;
-export type ActiveElementMessage = typeof ActiveElementMessage.Type;
-/**
- * Focus changes on the document. Without a document the stream is empty
- * instead of throwing. Lift with `Subscription.persistentEntry`, mapping into
- * the parent's Message.
- */
-export declare const activeElementEvents: () => Stream.Stream<ActiveElementMessage>;
-//#endregion
-//#region src/events/hotkeys.d.ts
-export interface KeyPress {
-  readonly key: string;
-  readonly repeat: boolean;
-  readonly ctrl: boolean;
-  readonly shift: boolean;
-  readonly alt: boolean;
-  readonly meta: boolean;
-}
-/**
- * Hotkey matching as a pure function over a `Pressed` payload: `matchHotkey`
- * answers whether a press is the shortcut, so `update` stays a table of
- * chords instead of a nest of modifier checks. Patterns read like
- * `"ctrl+shift+k"`: modifiers first (any order), the key last,
- * case-insensitive, with `cmd`/`command` and `option` as the Mac names for
- * meta and alt. Matching is exact — unlisted modifiers must be up — and
- * auto-repeat never matches, so holding a chord fires once. `space` (or a
- * bare space) means the space key; `esc` means escape. A pattern with
- * no key, or two keys, matches nothing: predicates return false, they do
- * not throw on the hot path.
- */
-export declare const matchHotkey: (pattern: string, press: KeyPress) => boolean;
-//#endregion
-//#region src/events/idle.d.ts
-export declare const IdleModel: Schema.Struct<{
-  readonly idle: Schema.Boolean;
-}>;
-export type IdleModel = typeof IdleModel.Type;
-export declare const IdleMessage: import("foldkit/message").MessageUnion<{
-  readonly BecameIdle: {};
-  readonly BecameActive: {};
-}>;
-export type IdleMessage = typeof IdleMessage.Type;
-/**
- * Idleness as a bundle: `idle` in the Model, flipped by activity and
- * silence. While active, activity debounced past `timeoutMs` settles to
- * `BecameIdle`; while idle, the first activity wakes to `BecameActive` and
- * the dependency flip restarts the watch. Starts active — a lurker idles
- * when the timeout elapses. The clock is Effect's, so tests drive it with
- * TestClock.
- */
-export declare const Idle: Bundle.Bundle<"Idle", {
-  readonly timeoutMs: number;
-}, {
-  readonly idle: boolean;
-}, {
-  readonly _tag: "BecameActive";
-} | {
-  readonly _tag: "BecameIdle";
-}, never, never, never, void, {}, {}>;
-//#endregion
-//#region src/events/keyboard.d.ts
-export declare const KeyboardMessage: import("foldkit/message").MessageUnion<{
-  readonly Pressed: {
-    key: Schema.String;
-    repeat: Schema.Boolean;
-    ctrl: Schema.Boolean;
-    shift: Schema.Boolean;
-    alt: Schema.Boolean;
-    meta: Schema.Boolean;
-  };
-  readonly Released: {
-    key: Schema.String;
-  };
-}>;
-export type KeyboardMessage = typeof KeyboardMessage.Type;
-/**
- * Key presses and releases on the window. Without a window the stream is
- * empty instead of throwing. Lift with `Subscription.persistentEntry`, mapping
- * into the parent's Message.
- */
-export declare const keyboardEvents: (options?: {
-  /**
-   * Whether to cancel a press's default (the page scrolling under an arrow
-   * key, the browser's own shortcut), decided in the listener, since a
-   * default can only be cancelled before the event finishes dispatching.
-   */
-  readonly preventDefault?: (press: KeyPress) => boolean;
-}) => Stream.Stream<KeyboardMessage>;
-//#endregion
-//#region src/events/pointer.d.ts
-export declare const PointerMessage: import("foldkit/message").MessageUnion<{
-  readonly Moved: {
-    x: Schema.Number;
-    y: Schema.Number;
-  };
-}>;
-export type PointerMessage = typeof PointerMessage.Type;
-/**
- * Pointer moves on the window. Without a window the stream is empty instead
- * of throwing. Lift with `Subscription.persistentEntry`, mapping into the
- * parent's Message.
- */
-export declare const pointerEvents: () => Stream.Stream<PointerMessage>;
-//#endregion
-//#region src/events/scroll.d.ts
-export declare const ScrollMessage: import("foldkit/message").MessageUnion<{
-  readonly Scrolled: {
-    x: Schema.Number;
-    y: Schema.Number;
-  };
-}>;
-export type ScrollMessage = typeof ScrollMessage.Type;
-/**
- * Scrolls on the window, in the capture phase so container scrolls (which
- * do not bubble) report too. Without a window the stream is empty instead
- * of throwing. Lift with `Subscription.persistentEntry`, mapping into the
- * parent's Message.
- */
-export declare const scrollEvents: () => Stream.Stream<ScrollMessage>;
-//#endregion
-//#region src/events/visibility.d.ts
-export declare const VisibilityModel: Schema.Struct<{
-  readonly visible: Schema.Boolean;
-}>;
-export type VisibilityModel = typeof VisibilityModel.Type;
-export declare const VisibilityMessage: import("foldkit/message").MessageUnion<{
-  readonly Changed: {
-    visible: Schema.Boolean;
-  };
-}>;
-export type VisibilityMessage = typeof VisibilityMessage.Type;
-/**
- * Page visibility as a bundle: `visible` in the Model, read from the
- * document at startup and kept current by `visibilitychange`. A hidden page
- * is the application's cue to pause polling, animations, and realtime
- * streams; the decision stays in application `update`, not here.
- */
-export declare const Visibility: Bundle.Bundle<"Visibility", void, {
-  readonly visible: boolean;
-}, {
-  readonly _tag: "Changed";
-  readonly visible: boolean;
-}, never, never, never, void, {}, {}>;
-//#endregion
-//#region src/events/window-size.d.ts
-export declare const WindowSizeModel: Schema.Struct<{
-  readonly width: Schema.Number;
-  readonly height: Schema.Number;
-}>;
-export type WindowSizeModel = typeof WindowSizeModel.Type;
-export declare const WindowSizeMessage: import("foldkit/message").MessageUnion<{
-  readonly Changed: {
-    width: Schema.Number;
-    height: Schema.Number;
-  };
-}>;
-export type WindowSizeMessage = typeof WindowSizeMessage.Type;
-/**
- * Window size as a bundle: `{ width, height }` in the Model, read from the
- * window at startup and kept current by one `resize` listener. Breakpoints
- * owns its own listener and derives names; place this one when views need
- * the raw pixels. Placing both doubles resize listeners — pick the one the
- * view reads.
- */
-export declare const WindowSize: Bundle.Bundle<"WindowSize", void, {
-  readonly width: number;
-  readonly height: number;
-}, {
-  readonly _tag: "Changed";
-  readonly width: number;
-  readonly height: number;
-}, never, never, never, void, {}, {}>;
-//#endregion
-export { InputModality, InputModalityMessage, InputModalityModel, Modality, modalityOfKey };
-//# sourceMappingURL=index.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/events/active-element.ts","../../src/events/hotkeys.ts","../../src/events/idle.ts","../../src/events/keyboard.ts","../../src/events/pointer.ts","../../src/events/scroll.ts","../../src/events/visibility.ts","../../src/events/window-size.ts"],"mappings":";;;;qBASa,gDAAoB;;IACpB,KAAG,OAAA;IAAiB,IAAE,OAAA,OAAA,OAAA;;;YAEvB,8BAA8B,qBAAqB;;;;;;qBAOlD,2BAA0B,OAAO,OAAO;;;iBCnBpC;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;;qBA8CE,cAAW,iBAAmB,OAAS;;;qBC9CvC,WAAS,OAAA;iBAAT,OAAA;;YACD,mBAAmB,UAAU;qBAE5B,uCAAW;;;;YACZ,qBAAqB,YAAY;;;;;;;;;qBAsBhC,MAAI,OAAA;;;;;;;;;;;qBCtBJ,2CAAe;;IAExB,KAAG,OAAA;IACH,QAAM,OAAA;IACN,MAAI,OAAA;IACJ,OAAK,OAAA;IACL,KAAG,OAAA;IACH,MAAI,OAAA;;;IAEM,KAAG,OAAA;;;YAEL,yBAAyB,gBAAgB;;;;;;qBAOxC,iBAAc;;;;;;WAOd,kBAAkB,OAAO;MAEnC,OAAO,OAAO;;;qBC5BJ,0CAAc;;IAChB,GAAC,OAAA;IAAiB,GAAC,OAAA;;;YAElB,wBAAwB,eAAe;;;;;;qBAOtC,qBAAoB,OAAO,OAAO;;;qBCVlC,yCAAa;;IACZ,GAAC,OAAA;IAAiB,GAAC,OAAA;;;YAErB,uBAAuB,cAAc;;;;;;;qBAQpC,oBAAmB,OAAO,OAAO;;;qBCfjC,iBAAe,OAAA;oBAAf,OAAA;;YACD,yBAAyB,gBAAgB;qBAExC,6CAAiB;;IAAmC,SAAO,OAAA;;;YAC5D,2BAA2B,kBAAkB;;;;;;;qBAuB5C,YAAU,OAAA;;;;;;;;qBC1BV,iBAAe,OAAA;;;;YAChB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;IACjB,OAAK,OAAA;IAAiB,QAAM,OAAA;;;YAE7B,2BAA2B,kBAAkB;;;;;;;;qBA0C5C,YAAU,OAAA"}