@tremolo-ui/dom 0.7.0 → 0.9.0

package/dist/marks-DK7xJmGM.d.cts

@@ -0,0 +1,305 @@
+//#region src/input/modifiers.d.ts
+/**
+ * Options for setting the amount of keyboard and mouse wheel changes.
+ */
+type InputEventOption = readonly ['normalized' | 'raw', number];
+/**
+ * A modifier key that can carry an amount of its own.
+ *
+ * `ctrl` and `meta` are kept apart rather than folded into one "command" key:
+ * a plugin UI that mirrors a desktop host usually wants the same physical key
+ * on every platform, not the platform's own convention.
+ */
+type Modifier = 'shift' | 'alt' | 'ctrl' | 'meta';
+/** The modifier flags of a `WheelEvent` or a `KeyboardEvent`. */
+interface ModifierState {
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+}
+/** One setting per modifier key, with `default` for none of them. */
+type ModifierSetting = number | InputEventOption;
+type ModifierMap<T extends ModifierSetting> = {
+  default: T;
+} & Partial<Record<Modifier, T>>;
+/**
+ * A single setting, or one per modifier key.
+ *
+ * @example
+ * ['raw', 1]
+ * { default: ['raw', 1], shift: ['raw', 0.1] }
+ */
+type ModifierValue<T extends ModifierSetting> = T | ModifierMap<T>;
+/**
+ * Pick the setting that applies, given the modifier keys being held.
+ *
+ * @example
+ * selectModifier({ default: 1, shift: 0.1 }, event)
+ */
+declare function selectModifier<T extends ModifierSetting>(options: ModifierValue<T>, modifiers?: ModifierState): {
+  value: T;
+  modifier: Modifier | null;
+};
+//#endregion
+//#region src/piano/layout.d.ts
+type NoteRange = {
+  first: number;
+  last: number;
+};
+/**
+ * `[noteRange.first, noteRange.first + 1, ..., noteRange.last]`
+ */
+declare function getNoteRangeArray(noteRange: NoteRange): number[];
+/**
+ * The geometry of a drawn keyboard.
+ *
+ * One description is shared by the drawing and the hit testing, so a key cannot
+ * be drawn somewhere other than where it responds.
+ */
+interface PianoLayout {
+  noteRange: NoteRange;
+  /** Width of a white key, excluding {@link PianoLayout.keyGap}. */
+  whiteKeyWidth: number;
+  /**
+   * Space between two white keys. Part of the slot a white key occupies, so it
+   * still belongs to one of the keys for the purpose of hit testing.
+   *
+   * @default 1
+   */
+  keyGap?: number;
+  /**
+   * Width of a black key, as a fraction of {@link PianoLayout.whiteKeyWidth}.
+   *
+   * @default 0.65
+   */
+  blackKeyWidthRatio?: number;
+  /**
+   * Height of a black key, as a fraction of the height of the keyboard.
+   *
+   * @default 0.6
+   */
+  blackKeyHeightRatio?: number;
+}
+/** Width of a black key in pixels. */
+declare function blackKeyWidth(layout: PianoLayout): number;
+/** Width of the whole keyboard in pixels. */
+declare function pianoWidth(layout: PianoLayout): number;
+/**
+ * Offset of the left edge of a key from the left edge of the keyboard, in
+ * pixels.
+ *
+ * Notes outside `noteRange` are placed too, so the value is negative below
+ * `noteRange.first`.
+ */
+declare function notePosition(note: number, layout: PianoLayout): number;
+/**
+ * The white key width that makes the keyboard exactly `width` wide, for a
+ * keyboard that follows the size of its container.
+ *
+ * Solved from {@link pianoWidth} rather than by dividing among the white
+ * keys, so that a range that starts or ends on a black key — which sticks out
+ * by a fraction of a white key — still fills the container. The width grows
+ * linearly with the white key width, so two samples pin it down.
+ */
+declare function fitWhiteKeyWidth(width: number, layout: Omit<PianoLayout, 'whiteKeyWidth'>): number;
+//#endregion
+//#region src/xy.d.ts
+/**
+ * A pair of per-axis values. The tuple elements are labelled, so editors show
+ * `[x: number, y: number]` rather than a bare pair.
+ */
+type XY<T> = [x: T, y: T];
+/**
+ * A setting that may be given once for both axes, or per axis.
+ *
+ * A single value is told from a pair with `Array.isArray`, so the single form
+ * is only offered while `T` cannot itself be an array. Where it can, the pair
+ * is the only way to write it, since a lone array would be read as a pair.
+ */
+type XYInput<T> = [T] extends [readonly unknown[]] ? readonly [x: T, y: T] : T | readonly [x: T, y: T];
+/**
+ * Spread a setting that may have been given as a single value.
+ *
+ * The parameter is written out rather than taken as `XYInput<T>`: a
+ * conditional type cannot be narrowed, so the constraint stays where it is
+ * declared and this takes both forms.
+ *
+ * The pair is copied rather than passed along, so that the result is a tuple
+ * the caller owns even when a readonly one was given.
+ */
+declare function toXY<T>(value: T | readonly [x: T, y: T]): XY<T>;
+//#endregion
+//#region src/selection/box.d.ts
+/**
+ * A rectangle in the 0..1 space of whatever the box is drawn over, with `y`
+ * growing downwards — the same space the items are given in.
+ */
+interface SelectionBoxRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+//#endregion
+//#region src/points-editor/index.d.ts
+/** Where a point is: 0..1 on each axis, with y growing downwards. */
+interface PointPosition {
+  x: number;
+  y: number;
+}
+/**
+ * A point's value is its position in the editor, so its range is the editor:
+ * no scaling, and no rounding to a step.
+ */
+declare const POINT_AXIS: {
+  min: number;
+  max: number;
+};
+/**
+ * How much one wheel notch moves a point by default: a hundredth of the
+ * editor, whatever its pixel size.
+ */
+declare const POINTS_EDITOR_DEFAULT_WHEEL: ModifierValue<InputEventOption>;
+/**
+ * How much one arrow key press moves a point by default. Shift is the
+ * fine-adjustment key everywhere else, so it is bound here too — but only on
+ * the keyboard. On the wheel it already means the x axis, and browsers hand
+ * shift+wheel over as horizontal scrolling anyway.
+ */
+declare const POINTS_EDITOR_DEFAULT_KEYBOARD: ModifierValue<InputEventOption>;
+/** Keep a point within its range. An axis left out runs from 0 to 1. */
+declare function clampPoint(point: PointPosition, min?: Partial<PointPosition>, max?: Partial<PointPosition>): PointPosition;
+/**
+ * What a point tells the editor about itself, so that a selection can be
+ * moved without the editor knowing how the points are stored.
+ */
+interface PointsEditorPoint {
+  value: PointPosition;
+  min?: Partial<PointPosition>;
+  max?: Partial<PointPosition>;
+  /** A point that cannot move stays put while the rest of a selection moves. */
+  readonly?: boolean;
+  onChange?: (value: PointPosition) => void;
+  /** The point's own element, to match the focus and a press against. */
+  element?: Element | null;
+  /** The wheel option the point resolved, `null` for no wheel. */
+  wheel?: ModifierValue<InputEventOption> | null;
+  /**
+   * Called just before the wheel moves this point as the focused one, so that
+   * it can report its change as started before the value arrives.
+   */
+  beforeWheel?: () => void;
+}
+interface PointsEditorOptions {
+  /**
+   * Let points be selected, and a selection be moved as one. While it is off
+   * nothing is selected, and a drag moves only the point it started on.
+   *
+   * @default false
+   */
+  selectable?: boolean;
+  /**
+   * The ids of the selected points. Whoever holds the selection pushes it
+   * back with `update()` after {@link PointsEditorOptions.onSelectionChange}.
+   */
+  selection?: readonly string[];
+  /** Called whenever a press or a selection box changes the selection. */
+  onSelectionChange?: (selection: string[]) => void;
+  /** Called whenever the selection box changes, with `null` once it is gone. */
+  onSelectionBoxChange?: (rect: SelectionBoxRect | null) => void;
+}
+interface PointsEditorInstance {
+  /** Replace the given options. */
+  update: (options: Partial<PointsEditorOptions>) => void;
+  /**
+   * Register a point under `id`. `read` is called whenever the editor needs
+   * the point, so it can return what the point is now rather than what it
+   * was when it registered. Returns the function that unregisters it.
+   */
+  registerPoint: (id: string, read: () => PointsEditorPoint) => () => void;
+  /** Whether the element is a point, or inside one. */
+  isPointElement: (element: Element | null | undefined) => boolean;
+  /**
+   * A pointer went down on a point: work out the new selection and remember
+   * where everything the drag picked up started.
+   *
+   * Ctrl / meta add the point to the selection or take it out: shift is the
+   * fine-adjustment key on every control here, and it cannot be both. A
+   * press on a point already selected keeps the selection, so the group can
+   * be dragged.
+   */
+  beginPointDrag: (id: string, modifiers: ModifierState) => void;
+  /**
+   * Move everything the drag picked up by `delta` from where it started,
+   * stopping the whole group together at the edge.
+   */
+  movePointDrag: (delta: PointPosition) => void;
+  /**
+   * Move `id` — and the selection, when it is part of one — by `delta` from
+   * where the points are now: an input that is not a drag has no earlier
+   * position to measure against.
+   */
+  nudgeSelection: (id: string, delta: PointPosition) => void;
+  /**
+   * Move `id` by one press of `option` along one axis, taking the selection
+   * along as {@link PointsEditorInstance.nudgeSelection} does.
+   */
+  nudgePoint: (id: string, axis: 'x' | 'y', direction: number, option: ModifierValue<InputEventOption>, modifiers?: ModifierState) => void;
+  /**
+   * Move the point holding the focus by one wheel notch, with its own wheel
+   * option. The wheel is listened to once for the whole editor, since a wheel
+   * event only reaches what the cursor is over. Returns whether a point took
+   * it, so the caller knows whether to consume the event.
+   */
+  nudgeFocusedPoint: (axis: 'x' | 'y', direction: number, modifiers: ModifierState) => boolean;
+  /** A drag on empty space started at `at`: start a selection box there. */
+  beginSelectionBox: (at: PointPosition, modifiers: ModifierState) => void;
+  moveSelectionBox: (to: PointPosition) => void;
+  /**
+   * End the selection box. The press that started it left the focus on
+   * nothing, and the arrow keys and the wheel reach a point only through the
+   * focus, so it is handed to one of the points the box selected.
+   */
+  endSelectionBox: () => void;
+  destroy: () => void;
+}
+/**
+ * The selection and the moves of a points editor: which points a press or a
+ * box selects, and how a selection moves as one.
+ *
+ * The points stay with the wrapper, which registers each one; the editor only
+ * reads them when it needs to, so a point's value can change on every frame
+ * of a drag without anything being re-registered.
+ */
+declare function createPointsEditor(options?: PointsEditorOptions): PointsEditorInstance;
+//#endregion
+//#region src/slider/marks.d.ts
+/**
+ * How `Slider.Marks` fills itself in when it is given no children: one option
+ * every `per`, or every `step` of the slider. The object form turns off the
+ * mark or the label for the whole set; a single option is customized by
+ * writing `Slider.MarksOption` out instead.
+ */
+type MarksOptions = 'step' | number | {
+  per: 'step' | number;
+  mark?: boolean;
+  label?: boolean;
+};
+/** One mark along a slider, as {@link sliderMarks} lays them out. */
+interface SliderMark {
+  value: number;
+  mark: boolean;
+  label: boolean;
+}
+/**
+ * The marks `options` asks for between `min` and `max`, in ascending order.
+ *
+ * Each value is a whole multiple of the interval, rounded to the digits the
+ * interval has: stepping by 0.1 would otherwise put binary debris in the
+ * labels (`0.1 * 3` is `0.30000000000000004`).
+ */
+declare function sliderMarks(options: MarksOptions, min: number, max: number, step: number): SliderMark[];
+//#endregion
+export { pianoWidth as C, ModifierState as D, ModifierMap as E, ModifierValue as O, notePosition as S, Modifier as T, NoteRange as _, POINTS_EDITOR_DEFAULT_WHEEL as a, fitWhiteKeyWidth as b, PointsEditorInstance as c, clampPoint as d, createPointsEditor as f, toXY as g, XYInput as h, POINTS_EDITOR_DEFAULT_KEYBOARD as i, selectModifier as k, PointsEditorOptions as l, XY as m, SliderMark as n, POINT_AXIS as o, SelectionBoxRect as p, sliderMarks as r, PointPosition as s, MarksOptions as t, PointsEditorPoint as u, PianoLayout as v, InputEventOption as w, getNoteRangeArray as x, blackKeyWidth as y };
+//# sourceMappingURL=marks-DK7xJmGM.d.cts.map

package/dist/marks-DK7xJmGM.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marks-DK7xJmGM.d.cts","names":[],"sources":["../src/input/modifiers.ts","../src/piano/layout.ts","../src/xy.ts","../src/selection/box.ts","../src/points-editor/index.ts","../src/slider/marks.ts"],"mappings":";;;;KAGY;;;;;;;;KASA;;UAGK;EACf;EACA;EACA;EACA;;;KAIG,2BAA2B;KAEpB,YAAY,UAAU;EAAqB,SAAS;IAAM,QACpE,OAAO,UAAU;;;;;;;;KAUP,cAAc,UAAU,mBAAmB,IAAI,YAAY;;;;;;;iBAqCvD,eAAe,UAAU,iBACvC,SAAS,cAAc,IACvB,YAAY;EACT,OAAO;EAAG,UAAU;;;;KCpEb;EACV;EACA;;;;;iBAMc,kBAAkB,WAAW;;;;;;;UAa5B;EACf,WAAW;;EAGX;;;;;;;EAQA;;;;;;EAOA;;;;;;EAOA;;;iBA8Bc,cAAc,QAAQ;;iBA0CtB,WAAW,QAAQ;;;;;;;;iBAYnB,aAAa,cAAc,QAAQ;;;;;;;;;;iBAsDnC,iBACd,eACA,QAAQ,KAAK;;;;;;;KC/LH,GAAG,MAAM,GAAG,GAAG,GAAG;;;;;;;;KASlB,QAAQ,MAAM,4CACZ,GAAG,GAAG,GAAG,KACnB,cAAc,GAAG,GAAG,GAAG;;;;;;;;;;;iBAoBX,KAAK,GAAG,OAAO,cAAc,GAAG,GAAG,GAAG,KAAK,GAAG;;;;;;;UC7B7C;EACf;EACA;EACA;EACA;;;;;UCEe;EACf;EACA;;;;;;cAOW;EAAA;EAAA;;;;;;cAMA,6BAA6B,cAAc;;;;;;;cAW3C,gCAAgC,cAAc;;iBAM3C,WACd,OAAO,eACP,MAAM,QAAQ,gBACd,MAAM,QAAQ,iBACb;;;;;UAWc;EACf,OAAO;EACP,MAAM,QAAQ;EACd,MAAM,QAAQ;;EAEd;EACA,YAAY,OAAO;;EAEnB,UAAU;;EAEV,QAAQ,cAAc;;;;;EAKtB;;UAGe;;;;;;;EAOf;;;;;EAKA;;EAEA,qBAAqB;;EAErB,wBAAwB,MAAM;;UAGf;;EAEf,SAAS,SAAS,QAAQ;;;;;;EAM1B,gBAAgB,YAAY,YAAY;;EAExC,iBAAiB,SAAS;;;;;;;;;;EAU1B,iBAAiB,YAAY,WAAW;;;;;EAKxC,gBAAgB,OAAO;;;;;;EAMvB,iBAAiB,YAAY,OAAO;;;;;EAKpC,aACE,YACA,iBACA,mBACA,QAAQ,cAAc,mBACtB,YAAY;;;;;;;EAQd,oBACE,iBACA,mBACA,WAAW;;EAGb,oBAAoB,IAAI,eAAe,WAAW;EAClD,mBAAmB,IAAI;;;;;;EAMvB;EACA;;;;;;;;;;iBA4Cc,mBACd,UAAS,sBACR;;;;;;;;;KCnMS;EAIN;EACA;EACA;;;UAIW;EACf;EACA;EACA;;;;;;;;;iBAUc,YACd,SAAS,cACT,aACA,aACA,eACC"}

package/dist/marks-DK7xJmGM.d.ts

@@ -0,0 +1,305 @@
+//#region src/input/modifiers.d.ts
+/**
+ * Options for setting the amount of keyboard and mouse wheel changes.
+ */
+type InputEventOption = readonly ['normalized' | 'raw', number];
+/**
+ * A modifier key that can carry an amount of its own.
+ *
+ * `ctrl` and `meta` are kept apart rather than folded into one "command" key:
+ * a plugin UI that mirrors a desktop host usually wants the same physical key
+ * on every platform, not the platform's own convention.
+ */
+type Modifier = 'shift' | 'alt' | 'ctrl' | 'meta';
+/** The modifier flags of a `WheelEvent` or a `KeyboardEvent`. */
+interface ModifierState {
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+}
+/** One setting per modifier key, with `default` for none of them. */
+type ModifierSetting = number | InputEventOption;
+type ModifierMap<T extends ModifierSetting> = {
+  default: T;
+} & Partial<Record<Modifier, T>>;
+/**
+ * A single setting, or one per modifier key.
+ *
+ * @example
+ * ['raw', 1]
+ * { default: ['raw', 1], shift: ['raw', 0.1] }
+ */
+type ModifierValue<T extends ModifierSetting> = T | ModifierMap<T>;
+/**
+ * Pick the setting that applies, given the modifier keys being held.
+ *
+ * @example
+ * selectModifier({ default: 1, shift: 0.1 }, event)
+ */
+declare function selectModifier<T extends ModifierSetting>(options: ModifierValue<T>, modifiers?: ModifierState): {
+  value: T;
+  modifier: Modifier | null;
+};
+//#endregion
+//#region src/piano/layout.d.ts
+type NoteRange = {
+  first: number;
+  last: number;
+};
+/**
+ * `[noteRange.first, noteRange.first + 1, ..., noteRange.last]`
+ */
+declare function getNoteRangeArray(noteRange: NoteRange): number[];
+/**
+ * The geometry of a drawn keyboard.
+ *
+ * One description is shared by the drawing and the hit testing, so a key cannot
+ * be drawn somewhere other than where it responds.
+ */
+interface PianoLayout {
+  noteRange: NoteRange;
+  /** Width of a white key, excluding {@link PianoLayout.keyGap}. */
+  whiteKeyWidth: number;
+  /**
+   * Space between two white keys. Part of the slot a white key occupies, so it
+   * still belongs to one of the keys for the purpose of hit testing.
+   *
+   * @default 1
+   */
+  keyGap?: number;
+  /**
+   * Width of a black key, as a fraction of {@link PianoLayout.whiteKeyWidth}.
+   *
+   * @default 0.65
+   */
+  blackKeyWidthRatio?: number;
+  /**
+   * Height of a black key, as a fraction of the height of the keyboard.
+   *
+   * @default 0.6
+   */
+  blackKeyHeightRatio?: number;
+}
+/** Width of a black key in pixels. */
+declare function blackKeyWidth(layout: PianoLayout): number;
+/** Width of the whole keyboard in pixels. */
+declare function pianoWidth(layout: PianoLayout): number;
+/**
+ * Offset of the left edge of a key from the left edge of the keyboard, in
+ * pixels.
+ *
+ * Notes outside `noteRange` are placed too, so the value is negative below
+ * `noteRange.first`.
+ */
+declare function notePosition(note: number, layout: PianoLayout): number;
+/**
+ * The white key width that makes the keyboard exactly `width` wide, for a
+ * keyboard that follows the size of its container.
+ *
+ * Solved from {@link pianoWidth} rather than by dividing among the white
+ * keys, so that a range that starts or ends on a black key — which sticks out
+ * by a fraction of a white key — still fills the container. The width grows
+ * linearly with the white key width, so two samples pin it down.
+ */
+declare function fitWhiteKeyWidth(width: number, layout: Omit<PianoLayout, 'whiteKeyWidth'>): number;
+//#endregion
+//#region src/xy.d.ts
+/**
+ * A pair of per-axis values. The tuple elements are labelled, so editors show
+ * `[x: number, y: number]` rather than a bare pair.
+ */
+type XY<T> = [x: T, y: T];
+/**
+ * A setting that may be given once for both axes, or per axis.
+ *
+ * A single value is told from a pair with `Array.isArray`, so the single form
+ * is only offered while `T` cannot itself be an array. Where it can, the pair
+ * is the only way to write it, since a lone array would be read as a pair.
+ */
+type XYInput<T> = [T] extends [readonly unknown[]] ? readonly [x: T, y: T] : T | readonly [x: T, y: T];
+/**
+ * Spread a setting that may have been given as a single value.
+ *
+ * The parameter is written out rather than taken as `XYInput<T>`: a
+ * conditional type cannot be narrowed, so the constraint stays where it is
+ * declared and this takes both forms.
+ *
+ * The pair is copied rather than passed along, so that the result is a tuple
+ * the caller owns even when a readonly one was given.
+ */
+declare function toXY<T>(value: T | readonly [x: T, y: T]): XY<T>;
+//#endregion
+//#region src/selection/box.d.ts
+/**
+ * A rectangle in the 0..1 space of whatever the box is drawn over, with `y`
+ * growing downwards — the same space the items are given in.
+ */
+interface SelectionBoxRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+//#endregion
+//#region src/points-editor/index.d.ts
+/** Where a point is: 0..1 on each axis, with y growing downwards. */
+interface PointPosition {
+  x: number;
+  y: number;
+}
+/**
+ * A point's value is its position in the editor, so its range is the editor:
+ * no scaling, and no rounding to a step.
+ */
+declare const POINT_AXIS: {
+  min: number;
+  max: number;
+};
+/**
+ * How much one wheel notch moves a point by default: a hundredth of the
+ * editor, whatever its pixel size.
+ */
+declare const POINTS_EDITOR_DEFAULT_WHEEL: ModifierValue<InputEventOption>;
+/**
+ * How much one arrow key press moves a point by default. Shift is the
+ * fine-adjustment key everywhere else, so it is bound here too — but only on
+ * the keyboard. On the wheel it already means the x axis, and browsers hand
+ * shift+wheel over as horizontal scrolling anyway.
+ */
+declare const POINTS_EDITOR_DEFAULT_KEYBOARD: ModifierValue<InputEventOption>;
+/** Keep a point within its range. An axis left out runs from 0 to 1. */
+declare function clampPoint(point: PointPosition, min?: Partial<PointPosition>, max?: Partial<PointPosition>): PointPosition;
+/**
+ * What a point tells the editor about itself, so that a selection can be
+ * moved without the editor knowing how the points are stored.
+ */
+interface PointsEditorPoint {
+  value: PointPosition;
+  min?: Partial<PointPosition>;
+  max?: Partial<PointPosition>;
+  /** A point that cannot move stays put while the rest of a selection moves. */
+  readonly?: boolean;
+  onChange?: (value: PointPosition) => void;
+  /** The point's own element, to match the focus and a press against. */
+  element?: Element | null;
+  /** The wheel option the point resolved, `null` for no wheel. */
+  wheel?: ModifierValue<InputEventOption> | null;
+  /**
+   * Called just before the wheel moves this point as the focused one, so that
+   * it can report its change as started before the value arrives.
+   */
+  beforeWheel?: () => void;
+}
+interface PointsEditorOptions {
+  /**
+   * Let points be selected, and a selection be moved as one. While it is off
+   * nothing is selected, and a drag moves only the point it started on.
+   *
+   * @default false
+   */
+  selectable?: boolean;
+  /**
+   * The ids of the selected points. Whoever holds the selection pushes it
+   * back with `update()` after {@link PointsEditorOptions.onSelectionChange}.
+   */
+  selection?: readonly string[];
+  /** Called whenever a press or a selection box changes the selection. */
+  onSelectionChange?: (selection: string[]) => void;
+  /** Called whenever the selection box changes, with `null` once it is gone. */
+  onSelectionBoxChange?: (rect: SelectionBoxRect | null) => void;
+}
+interface PointsEditorInstance {
+  /** Replace the given options. */
+  update: (options: Partial<PointsEditorOptions>) => void;
+  /**
+   * Register a point under `id`. `read` is called whenever the editor needs
+   * the point, so it can return what the point is now rather than what it
+   * was when it registered. Returns the function that unregisters it.
+   */
+  registerPoint: (id: string, read: () => PointsEditorPoint) => () => void;
+  /** Whether the element is a point, or inside one. */
+  isPointElement: (element: Element | null | undefined) => boolean;
+  /**
+   * A pointer went down on a point: work out the new selection and remember
+   * where everything the drag picked up started.
+   *
+   * Ctrl / meta add the point to the selection or take it out: shift is the
+   * fine-adjustment key on every control here, and it cannot be both. A
+   * press on a point already selected keeps the selection, so the group can
+   * be dragged.
+   */
+  beginPointDrag: (id: string, modifiers: ModifierState) => void;
+  /**
+   * Move everything the drag picked up by `delta` from where it started,
+   * stopping the whole group together at the edge.
+   */
+  movePointDrag: (delta: PointPosition) => void;
+  /**
+   * Move `id` — and the selection, when it is part of one — by `delta` from
+   * where the points are now: an input that is not a drag has no earlier
+   * position to measure against.
+   */
+  nudgeSelection: (id: string, delta: PointPosition) => void;
+  /**
+   * Move `id` by one press of `option` along one axis, taking the selection
+   * along as {@link PointsEditorInstance.nudgeSelection} does.
+   */
+  nudgePoint: (id: string, axis: 'x' | 'y', direction: number, option: ModifierValue<InputEventOption>, modifiers?: ModifierState) => void;
+  /**
+   * Move the point holding the focus by one wheel notch, with its own wheel
+   * option. The wheel is listened to once for the whole editor, since a wheel
+   * event only reaches what the cursor is over. Returns whether a point took
+   * it, so the caller knows whether to consume the event.
+   */
+  nudgeFocusedPoint: (axis: 'x' | 'y', direction: number, modifiers: ModifierState) => boolean;
+  /** A drag on empty space started at `at`: start a selection box there. */
+  beginSelectionBox: (at: PointPosition, modifiers: ModifierState) => void;
+  moveSelectionBox: (to: PointPosition) => void;
+  /**
+   * End the selection box. The press that started it left the focus on
+   * nothing, and the arrow keys and the wheel reach a point only through the
+   * focus, so it is handed to one of the points the box selected.
+   */
+  endSelectionBox: () => void;
+  destroy: () => void;
+}
+/**
+ * The selection and the moves of a points editor: which points a press or a
+ * box selects, and how a selection moves as one.
+ *
+ * The points stay with the wrapper, which registers each one; the editor only
+ * reads them when it needs to, so a point's value can change on every frame
+ * of a drag without anything being re-registered.
+ */
+declare function createPointsEditor(options?: PointsEditorOptions): PointsEditorInstance;
+//#endregion
+//#region src/slider/marks.d.ts
+/**
+ * How `Slider.Marks` fills itself in when it is given no children: one option
+ * every `per`, or every `step` of the slider. The object form turns off the
+ * mark or the label for the whole set; a single option is customized by
+ * writing `Slider.MarksOption` out instead.
+ */
+type MarksOptions = 'step' | number | {
+  per: 'step' | number;
+  mark?: boolean;
+  label?: boolean;
+};
+/** One mark along a slider, as {@link sliderMarks} lays them out. */
+interface SliderMark {
+  value: number;
+  mark: boolean;
+  label: boolean;
+}
+/**
+ * The marks `options` asks for between `min` and `max`, in ascending order.
+ *
+ * Each value is a whole multiple of the interval, rounded to the digits the
+ * interval has: stepping by 0.1 would otherwise put binary debris in the
+ * labels (`0.1 * 3` is `0.30000000000000004`).
+ */
+declare function sliderMarks(options: MarksOptions, min: number, max: number, step: number): SliderMark[];
+//#endregion
+export { pianoWidth as C, ModifierState as D, ModifierMap as E, ModifierValue as O, notePosition as S, Modifier as T, NoteRange as _, POINTS_EDITOR_DEFAULT_WHEEL as a, fitWhiteKeyWidth as b, PointsEditorInstance as c, clampPoint as d, createPointsEditor as f, toXY as g, XYInput as h, POINTS_EDITOR_DEFAULT_KEYBOARD as i, selectModifier as k, PointsEditorOptions as l, XY as m, SliderMark as n, POINT_AXIS as o, SelectionBoxRect as p, sliderMarks as r, PointPosition as s, MarksOptions as t, PointsEditorPoint as u, PianoLayout as v, InputEventOption as w, getNoteRangeArray as x, blackKeyWidth as y };
+//# sourceMappingURL=marks-DK7xJmGM.d.ts.map

package/dist/marks-DK7xJmGM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marks-DK7xJmGM.d.ts","names":[],"sources":["../src/input/modifiers.ts","../src/piano/layout.ts","../src/xy.ts","../src/selection/box.ts","../src/points-editor/index.ts","../src/slider/marks.ts"],"mappings":";;;;KAGY;;;;;;;;KASA;;UAGK;EACf;EACA;EACA;EACA;;;KAIG,2BAA2B;KAEpB,YAAY,UAAU;EAAqB,SAAS;IAAM,QACpE,OAAO,UAAU;;;;;;;;KAUP,cAAc,UAAU,mBAAmB,IAAI,YAAY;;;;;;;iBAqCvD,eAAe,UAAU,iBACvC,SAAS,cAAc,IACvB,YAAY;EACT,OAAO;EAAG,UAAU;;;;KCpEb;EACV;EACA;;;;;iBAMc,kBAAkB,WAAW;;;;;;;UAa5B;EACf,WAAW;;EAGX;;;;;;;EAQA;;;;;;EAOA;;;;;;EAOA;;;iBA8Bc,cAAc,QAAQ;;iBA0CtB,WAAW,QAAQ;;;;;;;;iBAYnB,aAAa,cAAc,QAAQ;;;;;;;;;;iBAsDnC,iBACd,eACA,QAAQ,KAAK;;;;;;;KC/LH,GAAG,MAAM,GAAG,GAAG,GAAG;;;;;;;;KASlB,QAAQ,MAAM,4CACZ,GAAG,GAAG,GAAG,KACnB,cAAc,GAAG,GAAG,GAAG;;;;;;;;;;;iBAoBX,KAAK,GAAG,OAAO,cAAc,GAAG,GAAG,GAAG,KAAK,GAAG;;;;;;;UC7B7C;EACf;EACA;EACA;EACA;;;;;UCEe;EACf;EACA;;;;;;cAOW;EAAA;EAAA;;;;;;cAMA,6BAA6B,cAAc;;;;;;;cAW3C,gCAAgC,cAAc;;iBAM3C,WACd,OAAO,eACP,MAAM,QAAQ,gBACd,MAAM,QAAQ,iBACb;;;;;UAWc;EACf,OAAO;EACP,MAAM,QAAQ;EACd,MAAM,QAAQ;;EAEd;EACA,YAAY,OAAO;;EAEnB,UAAU;;EAEV,QAAQ,cAAc;;;;;EAKtB;;UAGe;;;;;;;EAOf;;;;;EAKA;;EAEA,qBAAqB;;EAErB,wBAAwB,MAAM;;UAGf;;EAEf,SAAS,SAAS,QAAQ;;;;;;EAM1B,gBAAgB,YAAY,YAAY;;EAExC,iBAAiB,SAAS;;;;;;;;;;EAU1B,iBAAiB,YAAY,WAAW;;;;;EAKxC,gBAAgB,OAAO;;;;;;EAMvB,iBAAiB,YAAY,OAAO;;;;;EAKpC,aACE,YACA,iBACA,mBACA,QAAQ,cAAc,mBACtB,YAAY;;;;;;;EAQd,oBACE,iBACA,mBACA,WAAW;;EAGb,oBAAoB,IAAI,eAAe,WAAW;EAClD,mBAAmB,IAAI;;;;;;EAMvB;EACA;;;;;;;;;;iBA4Cc,mBACd,UAAS,sBACR;;;;;;;;;KCnMS;EAIN;EACA;EACA;;;UAIW;EACf;EACA;EACA;;;;;;;;;iBAUc,YACd,SAAS,cACT,aACA,aACA,eACC"}