@tremolo-ui/dom 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,13 +1,265 @@
+import { clamp, linearScale, normalizeValue, noteAt, stepValue, toPrecision } from "@tremolo-ui/functions";
+//#region src/canvas/context.ts
+/**
+* The assignable parts of a 2D context's drawing state. They have to be
+* carried across a resize by hand because setting `canvas.width` resets the
+* context to its defaults. The transform and line dash are handled separately
+* by {@link DrawingContext} because they are exposed through methods.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/save
+*/
+const drawingState = [
+	"strokeStyle",
+	"fillStyle",
+	"globalAlpha",
+	"lineWidth",
+	"lineCap",
+	"lineJoin",
+	"miterLimit",
+	"lineDashOffset",
+	"shadowOffsetX",
+	"shadowOffsetY",
+	"shadowBlur",
+	"shadowColor",
+	"globalCompositeOperation",
+	"filter",
+	"font",
+	"fontKerning",
+	"fontStretch",
+	"fontVariantCaps",
+	"textAlign",
+	"textBaseline",
+	"direction",
+	"letterSpacing",
+	"textRendering",
+	"wordSpacing",
+	"imageSmoothingEnabled",
+	"imageSmoothingQuality"
+];
+function isDrawingState(value) {
+	return typeof value === "string" && drawingState.includes(value);
+}
+/** Copy the drawing state off a context, to put back after a resize. */
+function readDrawingState(context) {
+	const state = {};
+	for (const property of drawingState) state[property] = context[property];
+	state.lineDash = context.getLineDash();
+	state.transform = context.getTransform();
+	return state;
+}
+/** Put a state read by {@link readDrawingState} back onto a context. */
+function writeDrawingState(context, state, transformScale = 1) {
+	for (const property of drawingState) context[property] = state[property];
+	context.setLineDash(state.lineDash);
+	const { a, b, c, d, e, f } = state.transform;
+	context.setTransform(a * transformScale, b * transformScale, c * transformScale, d * transformScale, e * transformScale, f * transformScale);
+}
+/**
+* Give the canvas a backing store of `width * dpr` by `height * dpr` device
+* pixels while keeping it `width` by `height` in CSS pixels, and scale the
+* context so that drawing code can work in CSS pixels throughout.
+*
+* Assigning to `canvas.width` clears the canvas and resets the context, so
+* this both resizes and re-establishes the transform.
+*/
+function applyDevicePixelRatio(canvas, context, width, height, dpr) {
+	canvas.width = width * dpr;
+	canvas.height = height * dpr;
+	context.setTransform(1, 0, 0, 1, 0, 0);
+	context.scale(dpr, dpr);
+	canvas.style.width = `${width}px`;
+	canvas.style.height = `${height}px`;
+}
+//#endregion
+//#region src/canvas/animation.ts
+/**
+* Drive a canvas from `requestAnimationFrame`, keeping its backing store in
+* step with the device pixel ratio and, optionally, with the size of its
+* parent.
+*
+* Drawing code works in CSS pixels: the context is scaled by the device pixel
+* ratio, and `width` / `height` of each {@link AnimationFrame} are CSS pixels.
+*/
+function createAnimationCanvas(canvas, options) {
+	let opts = options;
+	const context2d = canvas.getContext("2d", opts.contextAttributes);
+	if (!context2d) throw new Error("createAnimationCanvas: cannot get a 2d context");
+	const context = context2d;
+	const resizable = opts.resizable ?? false;
+	/** Off-document canvas holding the drawing while the real one is resized. */
+	let memo = null;
+	let memoContext = null;
+	let width = 0;
+	let height = 0;
+	let appliedDpr = 0;
+	/** Whether a size has been applied, so a frame can be drawn. */
+	let sized = false;
+	let initialized = false;
+	let frameId = null;
+	let count = -1;
+	const startTime = performance.now();
+	let previousTime = startTime;
+	function devicePixelRatio() {
+		return globalThis.devicePixelRatio || 1;
+	}
+	/**
+	* Copy the canvas onto the memo canvas at its full device resolution, 1:1.
+	*
+	* Assigning to `memo.width` resets the memo's transform to the identity, so
+	* the copy neither scales nor resamples.
+	*/
+	function takeSnapshot() {
+		if (!(opts.reduceFlickering ?? true)) return false;
+		if (!memo) {
+			memo = globalThis.document?.createElement("canvas") ?? null;
+			memoContext = memo?.getContext("2d", opts.contextAttributes) ?? null;
+		}
+		if (!memo || !memoContext) return false;
+		memo.width = canvas.width;
+		memo.height = canvas.height;
+		if (canvas.width > 0 && canvas.height > 0) memoContext.drawImage(canvas, 0, 0);
+		return true;
+	}
+	/**
+	* Put the snapshot back, given the size in CSS pixels it was taken at.
+	*
+	* The context is scaled to CSS pixels, so drawing the snapshot at its old
+	* CSS size leaves it exactly where it was. While the device pixel ratio
+	* stays put that is a 1:1 copy of device pixels, and when it changes the
+	* snapshot is rescaled once, from its full resolution.
+	*/
+	function restoreSnapshot(hasSnapshot, previousWidth, previousHeight) {
+		if (!hasSnapshot || !memo) return;
+		if (memo.width <= 0 || memo.height <= 0) return;
+		context.drawImage(memo, 0, 0, previousWidth, previousHeight);
+	}
+	function applySize(w, h) {
+		const dpr = devicePixelRatio();
+		const previousWidth = width;
+		const previousHeight = height;
+		const previousDpr = appliedDpr;
+		const state = sized ? readDrawingState(context) : null;
+		const hasSnapshot = sized && takeSnapshot();
+		applyDevicePixelRatio(canvas, context, w, h, dpr);
+		width = w;
+		height = h;
+		appliedDpr = dpr;
+		sized = true;
+		restoreSnapshot(hasSnapshot, previousWidth, previousHeight);
+		if (state) writeDrawingState(context, state, dpr / previousDpr);
+	}
+	function applyDevicePixelRatioIfNeeded() {
+		if (sized && devicePixelRatio() !== appliedDpr) applySize(width, height);
+	}
+	function drawFrame(timestamp = performance.now()) {
+		if (!sized) return;
+		applyDevicePixelRatioIfNeeded();
+		if (!initialized) {
+			initialized = true;
+			opts.init?.(context, {
+				width,
+				height
+			});
+		}
+		const deltaTime = timestamp - previousTime;
+		previousTime = timestamp;
+		count += 1;
+		opts.draw(context, {
+			width,
+			height,
+			count,
+			deltaTime,
+			elapsedTime: timestamp - startTime,
+			fps: deltaTime > 0 ? 1e3 / deltaTime : 0
+		});
+	}
+	function tick(timestamp) {
+		frameId = requestAnimationFrame(tick);
+		drawFrame(timestamp);
+	}
+	function startLoop() {
+		if (frameId !== null) return;
+		previousTime = performance.now();
+		frameId = requestAnimationFrame(tick);
+	}
+	function stopLoop() {
+		if (frameId === null) return;
+		cancelAnimationFrame(frameId);
+		frameId = null;
+	}
+	let observer = null;
+	if (resizable) {
+		const parent = canvas.parentElement;
+		if (!parent) throw new Error("createAnimationCanvas: resizable needs the canvas to have a parent element");
+		observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				const { width: w, height: h } = entry.contentRect;
+				if (w !== width || h !== height || devicePixelRatio() !== appliedDpr) applySize(w, h);
+				if (!(opts.animate ?? true)) drawFrame();
+			}
+		});
+		observer.observe(parent);
+	} else {
+		const { width: w = 100, height: h = 100 } = opts.size ?? {};
+		applySize(w, h);
+	}
+	if (opts.animate ?? true) startLoop();
+	else if (sized) drawFrame();
+	return {
+		update: (next) => {
+			const wasAnimating = opts.animate ?? true;
+			opts = {
+				...opts,
+				...next,
+				resizable,
+				contextAttributes: opts.contextAttributes
+			};
+			if (!resizable) {
+				const { width: w = 100, height: h = 100 } = opts.size ?? {};
+				if (w !== width || h !== height) applySize(w, h);
+			}
+			applyDevicePixelRatioIfNeeded();
+			const animating = opts.animate ?? true;
+			if (animating && !wasAnimating) startLoop();
+			if (!animating && wasAnimating) stopLoop();
+			if (!animating) drawFrame();
+		},
+		redraw: drawFrame,
+		destroy: () => {
+			stopLoop();
+			observer?.disconnect();
+			observer = null;
+			memo = null;
+			memoContext = null;
+		}
+	};
+}
+//#endregion
 //#region src/midi/access.ts
 /** @private */
 const PERMISSION_DENIED = "PERMISSION_DENIED";
 /** @private */
 const NOT_SUPPORTED = "NOT_SUPPORTED";
+/** @private */
+const UNAVAILABLE = "UNAVAILABLE";
 const INITIAL_STATE = {
 	midiAccess: null,
-	error: null
+	error: null,
+	inputs: []
 };
 /**
+* Which of our errors a rejected `requestMIDIAccess()` amounts to.
+*
+* The spec names the reasons, and they need telling apart: a user who said no
+* can say yes on a second ask, while a browser without the API never will.
+*/
+function toError(reason) {
+	const name = typeof reason === "object" && reason !== null && "name" in reason ? String(reason.name) : "";
+	if (name === "SecurityError" || name === "NotAllowedError") return PERMISSION_DENIED;
+	if (name === "NotSupportedError" || name === "TypeError") return NOT_SUPPORTED;
+	return UNAVAILABLE;
+}
+/**
 * Request MIDI access in the browser.
 *
 * The returned instance holds the state and notifies subscribers when it changes,
@@ -16,13 +268,31 @@ const INITIAL_STATE = {
 function createMIDIAccess() {
 	let state = INITIAL_STATE;
 	let destroyed = false;
+	let access = null;
+	let requestGeneration = 0;
 	const listeners = /* @__PURE__ */ new Set();
 	function setState(next) {
 		state = next;
 		for (const listener of listeners) listener();
 	}
-	function request() {
+	/**
+	* A new array every time, so that `useSyncExternalStore` and its equivalents
+	* see the change. The identity of the state object is what they compare.
+	*/
+	function readInputs() {
+		return access ? [...access.inputs.values()] : [];
+	}
+	function handleStateChange(event) {
+		if (destroyed || !access) return;
+		if (event && event.port?.type === "output") return;
+		setState({
+			...state,
+			inputs: readInputs()
+		});
+	}
+	function request(options = {}) {
 		if (destroyed) return;
+		const generation = ++requestGeneration;
 		if (typeof navigator === "undefined" || !navigator.requestMIDIAccess) {
 			setState({
 				...state,
@@ -30,17 +300,21 @@ function createMIDIAccess() {
 			});
 			return;
 		}
-		navigator.requestMIDIAccess().then((access) => {
-			if (destroyed) return;
+		navigator.requestMIDIAccess({ sysex: options.sysex ?? false }).then((granted) => {
+			if (destroyed || generation !== requestGeneration) return;
+			access?.removeEventListener("statechange", handleStateChange);
+			access = granted;
+			granted.addEventListener("statechange", handleStateChange);
 			setState({
-				midiAccess: access,
-				error: null
+				midiAccess: granted,
+				error: null,
+				inputs: readInputs()
 			});
-		}).catch(() => {
-			if (destroyed) return;
+		}, (reason) => {
+			if (destroyed || generation !== requestGeneration) return;
 			setState({
 				...state,
-				error: PERMISSION_DENIED
+				error: toError(reason)
 			});
 		});
 	}
@@ -56,6 +330,9 @@ function createMIDIAccess() {
 		},
 		destroy: () => {
 			destroyed = true;
+			requestGeneration += 1;
+			access?.removeEventListener("statechange", handleStateChange);
+			access = null;
 			listeners.clear();
 		}
 	};
@@ -65,35 +342,110 @@ function createMIDIAccess() {
 /**
 * Listen to raw `midimessage` events on every input of a MIDIAccess.
 *
+* The set of inputs is followed rather than sampled: MIDIAccess fires
+* `statechange` when a device is plugged in or unplugged, and the listeners
+* move with it. A keyboard connected after access was granted works without
+* the caller having to rebuild anything.
+*
 * Use this when you need more detail than {@link createMIDIInput} provides.
 */
 function createMIDIMessage(midiAccess, onMIDIMessage) {
-	if (!midiAccess) return { destroy: () => {} };
-	const inputs = [...midiAccess.inputs.values()];
-	for (const input of inputs) input.addEventListener("midimessage", onMIDIMessage);
-	return { destroy: () => {
-		for (const input of inputs) input.removeEventListener("midimessage", onMIDIMessage);
-	} };
+	let handler = onMIDIMessage;
+	/** Inputs this instance currently listens on. */
+	const attached = /* @__PURE__ */ new Set();
+	const listener = (event) => handler(event);
+	function sync() {
+		if (!midiAccess) return;
+		const connected = new Set(midiAccess.inputs.values());
+		for (const input of connected) {
+			if (attached.has(input)) continue;
+			input.addEventListener("midimessage", listener);
+			attached.add(input);
+		}
+		for (const input of [...attached]) {
+			if (connected.has(input)) continue;
+			input.removeEventListener("midimessage", listener);
+			attached.delete(input);
+		}
+	}
+	sync();
+	midiAccess?.addEventListener("statechange", sync);
+	return {
+		update: (next) => {
+			handler = next;
+		},
+		destroy: () => {
+			midiAccess?.removeEventListener("statechange", sync);
+			for (const input of attached) input.removeEventListener("midimessage", listener);
+			attached.clear();
+		}
+	};
 }
 //#endregion
 //#region src/midi/input.ts
-const MIDI_EVENT_TO_NUMBER = {
-	NOTE_ON: 144,
+/** Status byte of each channel message, with the channel nibble cleared. */
+const STATUS = {
 	NOTE_OFF: 128,
+	NOTE_ON: 144,
+	AFTERTOUCH: 160,
+	CONTROL_CHANGE: 176,
+	PROGRAM_CHANGE: 192,
+	CHANNEL_PRESSURE: 208,
 	PITCH_BEND: 224
 };
 /**
-* Handle note on/off and pitch bend events. To be used with {@link createMIDIAccess}.
-* Internally uses {@link createMIDIMessage}.
+* Centre of the 14-bit pitch bend range: no bend.
+*
+* The range is not symmetric — 0 is 8192 below centre and 16383 is 8191 above
+* — so a wheel at rest reports exactly this rather than half of the maximum.
 */
-function createMIDIInput(midiAccess, { onNoteOnEvent, onNoteOffEvent, onPitchBendEvent }) {
-	return createMIDIMessage(midiAccess, (event) => {
-		if (!event.data) return;
-		const kind = event.data[0] & 240;
-		if (kind == MIDI_EVENT_TO_NUMBER.NOTE_OFF || kind == MIDI_EVENT_TO_NUMBER.NOTE_ON && event.data[2] == 0) onNoteOffEvent?.(event.data[1]);
-		else if (kind == MIDI_EVENT_TO_NUMBER.NOTE_ON) onNoteOnEvent?.(event.data[1], event.data[2]);
-		else if (kind == MIDI_EVENT_TO_NUMBER.PITCH_BEND) onPitchBendEvent?.(event.data[1], event.data[2]);
-	});
+const PITCH_BEND_CENTER = 8192;
+/**
+* Handle the channel voice messages of every connected input. To be used with
+* {@link createMIDIAccess}. Internally uses {@link createMIDIMessage}, so
+* devices plugged in later are picked up.
+*
+* System messages (clock, sysex, and the rest of `0xf0`-`0xff`) are not
+* decoded here; reach for {@link createMIDIMessage} for those.
+*/
+function createMIDIInput(midiAccess, handlers) {
+	let current = handlers;
+	return {
+		update: (next) => {
+			current = next;
+		},
+		destroy: createMIDIMessage(midiAccess, (event) => {
+			if (!event.data || event.data.length === 0) return;
+			const status = event.data[0];
+			if (status >= 240) return;
+			const kind = status & 240;
+			const channel = status & 15;
+			const first = event.data[1] ?? 0;
+			const second = event.data[2] ?? 0;
+			switch (kind) {
+				case STATUS.NOTE_OFF:
+					current.onNoteOffEvent?.(first, channel);
+					break;
+				case STATUS.NOTE_ON:
+					if (second === 0) current.onNoteOffEvent?.(first, channel);
+					else current.onNoteOnEvent?.(first, second, channel);
+					break;
+				case STATUS.AFTERTOUCH:
+					current.onAftertouchEvent?.(first, second, channel);
+					break;
+				case STATUS.CONTROL_CHANGE:
+					current.onControlChangeEvent?.(first, second, channel);
+					break;
+				case STATUS.PROGRAM_CHANGE:
+					current.onProgramChangeEvent?.(first, channel);
+					break;
+				case STATUS.CHANNEL_PRESSURE:
+					current.onChannelPressureEvent?.(first, channel);
+					break;
+				case STATUS.PITCH_BEND: current.onPitchBendEvent?.(second << 7 | first, channel);
+			}
+		}).destroy
+	};
 }
 //#endregion
 //#region src/pointer/drag.ts
@@ -110,6 +462,7 @@ const MANAGED_STYLES = [
 	["-webkit-user-select", "none"],
 	["-webkit-touch-callout", "none"]
 ];
+const managedStyleStates = /* @__PURE__ */ new WeakMap();
 /**
 * Track a pointer drag on an element.
 *
@@ -118,32 +471,54 @@ const MANAGED_STYLES = [
 * element gets `touch-action: none` so that touch dragging does not scroll the
 * page, plus `user-select: none` so that a long press does not start a text
 * selection instead.
+*
+* One pointer at a time by default; see {@link DragOptions.multiPointer}.
 */
-function createDrag(element, { threshold: _threshold = 1, cursor, onDragStart, onDrag, onDragEnd } = {}) {
-	const threshold = Math.max(_threshold, 1);
+function createDrag(element, options = {}) {
+	let opts = options;
+	const multiPointer = options.multiPointer ?? false;
 	const capture = element;
 	const style = element.style;
-	const previousStyles = /* @__PURE__ */ new Map();
-	if (style) for (const [property, value] of MANAGED_STYLES) {
-		previousStyles.set(property, style.getPropertyValue(property));
-		style.setProperty(property, value);
-	}
-	let pointerId = null;
-	/** Where the listeners for the current drag live. */
-	let moveTarget = null;
-	let startX = 0;
-	let startY = 0;
-	let lastX = 0;
-	let lastY = 0;
+	let managedStyles = managedStyleStates.get(element);
+	if (style) {
+		if (managedStyles) managedStyles.count += 1;
+		else {
+			const previous = /* @__PURE__ */ new Map();
+			for (const [property, value] of MANAGED_STYLES) {
+				previous.set(property, {
+					value: style.getPropertyValue(property),
+					priority: style.getPropertyPriority(property)
+				});
+				style.setProperty(property, value);
+			}
+			managedStyles = {
+				count: 1,
+				previous
+			};
+			managedStyleStates.set(element, managedStyles);
+		}
+	}
+	const pointers = /* @__PURE__ */ new Map();
+	/**
+	* How many pointers each target carries. Adding the same listener twice is a
+	* no-op and removing it once removes it for good, so a target is subscribed
+	* to while at least one pointer is on it and no longer.
+	*/
+	const targets = /* @__PURE__ */ new Map();
 	let previousCursor;
-	function state(event, deltaX, deltaY) {
+	/** The pointer that asked for the lock, while it is still down. */
+	let lockedPointerId = null;
+	let lockRequest = 0;
+	let destroyed = false;
+	function state(event, pointer, deltaX, deltaY) {
 		return {
-			x: event.screenX - startX,
-			y: event.screenY - startY,
+			x: pointer.lockBaseX !== void 0 ? pointer.lockBaseX + pointer.lockMoveX : event.screenX - pointer.startX,
+			y: pointer.lockBaseY !== void 0 ? pointer.lockBaseY + pointer.lockMoveY : event.screenY - pointer.startY,
 			deltaX,
 			deltaY,
 			clientX: event.clientX,
 			clientY: event.clientY,
+			pointerId: event.pointerId,
 			event
 		};
 	}
@@ -155,65 +530,437 @@ function createDrag(element, { threshold: _threshold = 1, cursor, onDragStart, o
 	function preventSelectStart(event) {
 		event.preventDefault();
 	}
+	function retainTarget(target) {
+		const count = targets.get(target) ?? 0;
+		if (count === 0) {
+			target.addEventListener("pointermove", handlePointerMove);
+			target.addEventListener("pointerup", handlePointerUp);
+			target.addEventListener("pointercancel", handlePointerUp);
+			if (target === element) target.addEventListener("lostpointercapture", handleLostPointerCapture);
+		}
+		targets.set(target, count + 1);
+	}
+	function releaseTarget(target) {
+		const count = targets.get(target) ?? 0;
+		if (count > 1) {
+			targets.set(target, count - 1);
+			return;
+		}
+		target.removeEventListener("pointermove", handlePointerMove);
+		target.removeEventListener("pointerup", handlePointerUp);
+		target.removeEventListener("pointercancel", handlePointerUp);
+		if (target === element) target.removeEventListener("lostpointercapture", handleLostPointerCapture);
+		targets.delete(target);
+	}
 	function handlePointerDown(event) {
 		const pointerEvent = event;
-		if (pointerId !== null) return;
-		pointerId = pointerEvent.pointerId;
-		startX = lastX = pointerEvent.screenX;
-		startY = lastY = pointerEvent.screenY;
-		if (cursor && style) {
+		if (pointerEvent.button !== 0) return;
+		const pointerId = pointerEvent.pointerId;
+		if (pointers.has(pointerId)) return;
+		if (!multiPointer && pointers.size > 0) return;
+		if (opts.shouldStart && !opts.shouldStart(pointerEvent)) return;
+		const isFirst = pointers.size === 0;
+		if (isFirst && opts.cursor && style) {
 			previousCursor = style.cursor;
-			style.cursor = cursor;
+			style.cursor = opts.cursor;
 		}
 		capture.setPointerCapture?.(pointerId);
-		moveTarget = capture.hasPointerCapture?.(pointerId) === true ? element : globalThis.window ?? element;
-		moveTarget.addEventListener("pointermove", handlePointerMove);
-		moveTarget.addEventListener("pointerup", handlePointerUp);
-		moveTarget.addEventListener("pointercancel", handlePointerUp);
-		globalThis.document?.addEventListener("selectstart", preventSelectStart);
-		onDragStart?.(state(pointerEvent, 0, 0));
+		const moveTarget = capture.hasPointerCapture?.(pointerId) === true ? element : globalThis.window ?? element;
+		const pointer = {
+			moveTarget,
+			startX: pointerEvent.screenX,
+			startY: pointerEvent.screenY,
+			lastX: pointerEvent.screenX,
+			lastY: pointerEvent.screenY,
+			lockMoveX: 0,
+			lockMoveY: 0,
+			lastEvent: pointerEvent
+		};
+		pointers.set(pointerId, pointer);
+		retainTarget(moveTarget);
+		if (isFirst) globalThis.document?.addEventListener("selectstart", preventSelectStart);
+		if (isFirst && opts.pointerLock) {
+			const requestId = ++lockRequest;
+			lockedPointerId = pointerId;
+			globalThis.document?.addEventListener("pointerlockchange", handleLockChange);
+			try {
+				(capture.requestPointerLock?.())?.then?.(() => {
+					if (requestId === lockRequest && (!pointers.has(pointerId) || destroyed) && globalThis.document?.pointerLockElement === element) globalThis.document.exitPointerLock?.();
+				}, () => {});
+			} catch {}
+		}
+		opts.onDragStart?.(state(pointerEvent, pointer, 0, 0));
 	}
 	function handlePointerMove(event) {
 		const pointerEvent = event;
-		if (pointerEvent.pointerId !== pointerId) return;
-		const deltaX = pointerEvent.screenX - lastX;
-		const deltaY = pointerEvent.screenY - lastY;
-		lastX = pointerEvent.screenX;
-		lastY = pointerEvent.screenY;
+		const pointer = pointers.get(pointerEvent.pointerId);
+		if (!pointer) return;
+		const locked = pointer.lockBaseX !== void 0;
+		const deltaX = locked ? pointerEvent.movementX ?? 0 : pointerEvent.screenX - pointer.lastX;
+		const deltaY = locked ? pointerEvent.movementY ?? 0 : pointerEvent.screenY - pointer.lastY;
+		const threshold = opts.threshold ?? 0;
 		if (Math.abs(deltaX) < threshold && Math.abs(deltaY) < threshold) return;
-		onDrag?.(state(pointerEvent, deltaX, deltaY));
+		pointer.lastX = pointerEvent.screenX;
+		pointer.lastY = pointerEvent.screenY;
+		pointer.lastEvent = pointerEvent;
+		if (locked) {
+			pointer.lockMoveX += deltaX;
+			pointer.lockMoveY += deltaY;
+		}
+		opts.onDrag?.(state(pointerEvent, pointer, deltaX, deltaY));
+	}
+	function handleLockChange() {
+		if (lockedPointerId === null) return;
+		const pointer = pointers.get(lockedPointerId);
+		if (!pointer) return;
+		if (globalThis.document?.pointerLockElement === element) {
+			pointer.lockBaseX = pointer.lastX - pointer.startX;
+			pointer.lockBaseY = pointer.lastY - pointer.startY;
+			pointer.lockMoveX = 0;
+			pointer.lockMoveY = 0;
+			return;
+		}
+		if (pointer.lockBaseX === void 0) return;
+		finishDrag(lockedPointerId);
 	}
 	function handlePointerUp(event) {
 		const pointerEvent = event;
-		if (pointerEvent.pointerId !== pointerId) return;
-		const finalState = state(pointerEvent, pointerEvent.screenX - lastX, pointerEvent.screenY - lastY);
-		stopTracking();
-		onDragEnd?.(finalState);
-	}
-	function stopTracking() {
-		if (pointerId === null) return;
-		capture.releasePointerCapture?.(pointerId);
-		moveTarget?.removeEventListener("pointermove", handlePointerMove);
-		moveTarget?.removeEventListener("pointerup", handlePointerUp);
-		moveTarget?.removeEventListener("pointercancel", handlePointerUp);
+		finishDrag(pointerEvent.pointerId, pointerEvent);
+	}
+	function handleLostPointerCapture(event) {
+		finishDrag(event.pointerId);
+	}
+	function finishDrag(pointerId, event) {
+		const pointer = pointers.get(pointerId);
+		if (!pointer) return;
+		const finalState = event ? state(event, pointer, event.screenX - pointer.lastX, event.screenY - pointer.lastY) : state(pointer.lastEvent, pointer, 0, 0);
+		stopTracking(pointerId);
+		opts.onDragEnd?.(finalState);
+	}
+	function stopTracking(pointerId) {
+		const pointer = pointers.get(pointerId);
+		if (!pointer) return;
+		pointers.delete(pointerId);
+		releaseTarget(pointer.moveTarget);
+		try {
+			if (capture.hasPointerCapture?.(pointerId) === true) capture.releasePointerCapture?.(pointerId);
+		} catch {}
+		if (lockedPointerId === pointerId) {
+			lockedPointerId = null;
+			const document = globalThis.document;
+			document?.removeEventListener("pointerlockchange", handleLockChange);
+			if (document?.pointerLockElement === element) document.exitPointerLock?.();
+		}
+		if (pointers.size > 0) return;
 		globalThis.document?.removeEventListener("selectstart", preventSelectStart);
-		if (cursor && style) {
-			style.cursor = previousCursor ?? "";
+		if (previousCursor !== void 0 && style) {
+			style.cursor = previousCursor;
 			previousCursor = void 0;
 		}
-		moveTarget = null;
-		pointerId = null;
 	}
 	element.addEventListener("pointerdown", handlePointerDown);
-	return { destroy: () => {
-		stopTracking();
-		element.removeEventListener("pointerdown", handlePointerDown);
-		if (style) for (const [property] of MANAGED_STYLES) {
-			const previous = previousStyles.get(property);
-			if (previous) style.setProperty(property, previous);
-			else style.removeProperty(property);
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next,
+				multiPointer
+			};
+		},
+		destroy: () => {
+			if (destroyed) return;
+			destroyed = true;
+			element.removeEventListener("pointerdown", handlePointerDown);
+			for (const pointerId of [...pointers.keys()]) finishDrag(pointerId);
+			if (style && managedStyles && --managedStyles.count === 0) {
+				for (const [property] of MANAGED_STYLES) {
+					const previous = managedStyles.previous.get(property);
+					if (previous?.value) style.setProperty(property, previous.value, previous.priority);
+					else style.removeProperty(property);
+				}
+				managedStyleStates.delete(element);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/piano/index.ts
+const DEFAULT_SOURCE = "api";
+/**
+* Drive a piano keyboard with pointers, and own what is sounding.
+*
+* Every way of playing a note goes through the one instance — pointers here,
+* keyboard shortcuts and MIDI through {@link PianoInputInstance.noteOn} — so
+* there is a single answer to what is currently held, and drawing the keys is
+* left entirely to the wrapper.
+*
+* Tracks every pointer at once, so a chord can be played with several fingers.
+*/
+function createPianoInput(element, options) {
+	let opts = options;
+	/** Which sources are holding each sounding note. */
+	const held = /* @__PURE__ */ new Map();
+	/** The note each pointer is currently on. */
+	const pointerNotes = /* @__PURE__ */ new Map();
+	function activeNotes() {
+		return [...held.keys()].sort((a, b) => a - b);
+	}
+	function noteOn(note, { source = DEFAULT_SOURCE, velocity } = {}) {
+		if (!Number.isInteger(note) || note < 0 || note > 127) throw new RangeError("note: requirements: an integer from 0 to 127");
+		if (note > (opts.midiMax ?? 127)) return;
+		const sources = held.get(note);
+		if (sources) {
+			sources.add(source);
+			return;
+		}
+		held.set(note, /* @__PURE__ */ new Set([source]));
+		opts.onPlayNote?.(note, velocity);
+		opts.onActiveNotesChange?.(activeNotes());
+	}
+	function noteOff(note, { source = DEFAULT_SOURCE } = {}) {
+		if (!Number.isInteger(note) || note < 0 || note > 127) throw new RangeError("note: requirements: an integer from 0 to 127");
+		const sources = held.get(note);
+		if (!sources) return;
+		sources.delete(source);
+		if (sources.size > 0) return;
+		held.delete(note);
+		opts.onStopNote?.(note);
+		opts.onActiveNotesChange?.(activeNotes());
+	}
+	/** The note under a pointer, or null where the pointer is off the keys. */
+	function noteUnder(clientX, clientY) {
+		const { left, top, height } = element.getBoundingClientRect();
+		return noteAt(clientX - left, clientY - top, height, opts.layout);
+	}
+	/** Move a pointer onto a note, releasing whatever it held before. */
+	function movePointer(pointerId, note) {
+		const source = `pointer:${pointerId}`;
+		const previous = pointerNotes.get(pointerId);
+		if (previous === note) return;
+		if (previous !== void 0) noteOff(previous, { source });
+		if (note === null || note > (opts.midiMax ?? 127)) pointerNotes.delete(pointerId);
+		else {
+			pointerNotes.set(pointerId, note);
+			noteOn(note, { source });
+		}
+	}
+	const drag = createDrag(element, {
+		multiPointer: true,
+		onDragStart: (state) => movePointer(state.pointerId, noteUnder(state.clientX, state.clientY)),
+		onDrag: (state) => {
+			if (opts.glissando === false) return;
+			movePointer(state.pointerId, noteUnder(state.clientX, state.clientY));
+		},
+		onDragEnd: (state) => movePointer(state.pointerId, null)
+	});
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next
+			};
+			const midiMax = opts.midiMax ?? 127;
+			const stoppedNotes = activeNotes().filter((note) => note > midiMax);
+			if (stoppedNotes.length === 0) return;
+			for (const note of stoppedNotes) {
+				held.delete(note);
+				opts.onStopNote?.(note);
+			}
+			for (const [pointerId, note] of pointerNotes) if (note > midiMax) pointerNotes.delete(pointerId);
+			opts.onActiveNotesChange?.(activeNotes());
+		},
+		noteOn,
+		noteOff,
+		activeNotes,
+		destroy: () => {
+			drag.destroy();
+			const notes = activeNotes();
+			for (const note of notes) {
+				held.delete(note);
+				opts.onStopNote?.(note);
+			}
+			pointerNotes.clear();
+			if (notes.length > 0) opts.onActiveNotesChange?.([]);
+		}
+	};
+}
+//#endregion
+//#region src/xy.ts
+function isPair(value) {
+	return Array.isArray(value);
+}
+/**
+* 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.
+*/
+function toXY(value) {
+	return isPair(value) ? [value[0], value[1]] : [value, value];
+}
+//#endregion
+//#region src/pointer/drag-value.ts
+/**
+* Map the pointer onto the bounding rect of an element: the value *is* the
+* position pointed at, so the middle of the element is 0.5.
+*
+* The element is read on every event, so it may be mounted after the drag is
+* set up and may change size while a drag is in progress.
+*/
+function elementMapping(getElement, { sensitivity } = {}) {
+	/** The reported position when the sensitivity last changed. */
+	let origin = [0, 0];
+	/** The raw position at that same moment. */
+	let anchor = [0, 0];
+	/** The previous event, so a sensitivity change can be dated back to it. */
+	let previous = [0, 0];
+	let factor = 1;
+	function positionIn(state) {
+		const element = getElement();
+		if (!element) return null;
+		const { left, top, right, bottom } = element.getBoundingClientRect();
+		return [right > left ? normalizeValue(state.clientX, left, right) : 0, bottom > top ? normalizeValue(state.clientY, top, bottom) : 0];
+	}
+	const reported = (raw, at) => [origin[0] + (raw[0] - anchor[0]) * at, origin[1] + (raw[1] - anchor[1]) * at];
+	return {
+		start: (state) => {
+			const raw = positionIn(state);
+			if (!raw) return null;
+			origin = raw;
+			anchor = raw;
+			previous = raw;
+			factor = sensitivity ? sensitivity(state) : 1;
+			return raw;
+		},
+		move: (state) => {
+			const raw = positionIn(state);
+			if (!raw) return null;
+			const next = sensitivity ? sensitivity(state) : 1;
+			if (next !== factor) {
+				origin = reported(previous, factor);
+				anchor = previous;
+				factor = next;
+			}
+			previous = raw;
+			return reported(raw, factor);
+		}
+	};
+}
+/**
+* Move the value away from where it stood when the drag started, by the
+* distance dragged. The pointer position itself carries no meaning, so the
+* value can be adjusted from anywhere on the screen.
+*/
+function relativeMapping({ pixelRange = 100, sensitivity } = {}) {
+	const [baseX, baseY] = toXY(pixelRange);
+	let origin = [0, 0];
+	/** Where the current sensitivity took over, in drag coordinates. */
+	let anchor = [0, 0];
+	/** The previous event, so a sensitivity change can be dated back to it. */
+	let previous = [0, 0];
+	let factor = 1;
+	const travelled = (to, at) => [baseX === 0 ? origin[0] : origin[0] + (to[0] - anchor[0]) * at / baseX, baseY === 0 ? origin[1] : origin[1] + (to[1] - anchor[1]) * at / baseY];
+	return {
+		start: (state, context) => {
+			origin = context.position();
+			anchor = [0, 0];
+			previous = [0, 0];
+			factor = sensitivity ? sensitivity(state) : 1;
+			return origin;
+		},
+		move: (state) => {
+			const next = sensitivity ? sensitivity(state) : 1;
+			if (next !== factor) {
+				origin = travelled(previous, factor);
+				anchor = previous;
+				factor = next;
+			}
+			previous = [state.x, state.y];
+			return travelled([state.x, state.y], factor);
 		}
+	};
+}
+/**
+* Drive a value with a pointer drag.
+*
+* Combines {@link createDrag} with the scaling of `@tremolo-ui/functions`: the
+* mapping decides where the pointer sits on the 0-1 travel of each axis, and
+* the axis options turn that into a value.
+*/
+function createDragValue(element, options) {
+	let opts = options;
+	let lastValue = [0, 0];
+	let active = false;
+	const axes = () => toXY(opts.axis);
+	function valueOf(position) {
+		return axes().map((axis, i) => {
+			const p = axis.reverse ? 1 - position[i] : position[i];
+			const value = (axis.scale ?? linearScale).denormalize(p, axis.min, axis.max);
+			const stepped = axis.step ? stepValue(value, axis.step) : value;
+			return clamp(toPrecision(stepped), axis.min, axis.max);
+		});
+	}
+	const context = { position: () => {
+		const getValue = opts.getValue;
+		if (!getValue) throw new Error("createDragValue: getValue is required by the given mapping");
+		const value = getValue();
+		return axes().map((axis, i) => {
+			const n = (axis.scale ?? linearScale).normalize(value[i], axis.min, axis.max);
+			return axis.reverse ? 1 - n : n;
+		});
 	} };
+	const drag = createDrag(element, {
+		threshold: opts.threshold,
+		cursor: opts.cursor,
+		pointerLock: opts.pointerLock,
+		shouldStart: (event) => opts.shouldStart?.(event) ?? true,
+		onDragStart: (state) => {
+			const position = opts.mapping.start(state, context);
+			if (!position) return;
+			active = true;
+			lastValue = valueOf(position);
+			if (opts.updateOnPointerDown) opts.onChange?.(lastValue, state);
+			opts.onDragStart?.(lastValue, state);
+		},
+		onDrag: (state) => {
+			if (!active) return;
+			const position = opts.mapping.move(state, context);
+			if (!position) return;
+			lastValue = valueOf(position);
+			opts.onChange?.(lastValue, state);
+		},
+		onDragEnd: (state) => {
+			if (!active) return;
+			if (state.event.type === "pointerup" && (state.deltaX !== 0 || state.deltaY !== 0)) {
+				const position = opts.mapping.move(state, context);
+				if (position) {
+					lastValue = valueOf(position);
+					opts.onChange?.(lastValue, state);
+				}
+			}
+			active = false;
+			opts.onDragEnd?.(lastValue, state);
+		}
+	});
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next,
+				mapping: opts.mapping
+			};
+			drag.update({
+				threshold: opts.threshold,
+				cursor: opts.cursor,
+				pointerLock: opts.pointerLock
+			});
+		},
+		destroy: () => drag.destroy()
+	};
 }
 //#endregion
 //#region src/pointer/wheel.ts
@@ -223,14 +970,100 @@ function createDrag(element, { threshold: _threshold = 1, cursor, onDragStart, o
 * The listener is registered with `passive: false` so that the handler can call
 * `preventDefault()` to stop the page from scrolling.
 */
-function createWheel(element, onWheel) {
-	const handler = (event) => onWheel(event);
+function createWheel(element, onWheel, options = {}) {
+	let opts = {
+		...options,
+		onWheel
+	};
+	function hasFocus() {
+		const active = element.ownerDocument?.activeElement;
+		return !!active && element.contains(active);
+	}
+	const handler = (event) => {
+		if (opts.requireFocus && !hasFocus()) return;
+		opts.onWheel?.(event);
+	};
 	element.addEventListener("wheel", handler, { passive: false });
-	return { destroy: () => {
-		element.removeEventListener("wheel", handler);
-	} };
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next
+			};
+		},
+		destroy: () => {
+			element.removeEventListener("wheel", handler);
+		}
+	};
+}
+//#endregion
+//#region src/selection/box.ts
+function rectOf(from, to) {
+	return {
+		x: Math.min(from[0], to[0]),
+		y: Math.min(from[1], to[1]),
+		width: Math.abs(to[0] - from[0]),
+		height: Math.abs(to[1] - from[1])
+	};
+}
+/** Whether the box covers the point, edges included. */
+function selectionBoxCovers(box, [x, y]) {
+	return x >= box.x && x <= box.x + box.width && y >= box.y && y <= box.y + box.height;
+}
+/**
+* Selecting by dragging a box over a set of items.
+*
+* The drag itself is not here: the caller owns the pointer, and reports where
+* it went in the same 0..1 space the items are given in.
+*/
+function createSelectionBox(options) {
+	let opts = options;
+	let drag = null;
+	let box = null;
+	function setBox(next) {
+		box = next;
+		opts.onBoxChange?.(next);
+	}
+	function apply(rect, base) {
+		const inside = [];
+		for (const [id, at] of opts.items()) if (selectionBoxCovers(rect, at) && !base.includes(id)) inside.push(id);
+		opts.onSelectionChange?.([...base, ...inside]);
+	}
+	return {
+		update: (next) => {
+			opts = {
+				...opts,
+				...next
+			};
+		},
+		begin: (at, { additive = false, selection = [] } = {}) => {
+			drag = {
+				from: at,
+				base: additive ? [...selection] : []
+			};
+			setBox(rectOf(at, at));
+			if (!additive) opts.onSelectionChange?.([]);
+		},
+		move: (to) => {
+			if (!drag) return;
+			const rect = rectOf(drag.from, to);
+			setBox(rect);
+			apply(rect, drag.base);
+		},
+		end: () => {
+			const running = drag !== null;
+			drag = null;
+			if (box !== null) setBox(null);
+			return running;
+		},
+		box: () => box,
+		destroy: () => {
+			drag = null;
+			box = null;
+		}
+	};
 }
 //#endregion
-export { NOT_SUPPORTED, PERMISSION_DENIED, createDrag, createMIDIAccess, createMIDIInput, createMIDIMessage, createWheel };
+export { NOT_SUPPORTED, PERMISSION_DENIED, PITCH_BEND_CENTER, UNAVAILABLE, createAnimationCanvas, createDrag, createDragValue, createMIDIAccess, createMIDIInput, createMIDIMessage, createPianoInput, createSelectionBox, createWheel, drawingState, elementMapping, isDrawingState, relativeMapping, selectionBoxCovers, toXY };
 
 //# sourceMappingURL=index.js.map