@tremolo-ui/react 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,146 +1,77 @@
 import clsx from "clsx";
-import React, { createContext, createRef, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useInsertionEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createContext, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useInsertionEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { NOT_SUPPORTED, PERMISSION_DENIED, createAnimationCanvas, createDrag, createDragValue, createMIDIAccess, createMIDIInput, createMIDIMessage, createPianoInput, createWheel, elementMapping, relativeMapping, toXY } from "@tremolo-ui/dom";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { clamp, decimalPart, isBlackKey, isWhiteKey, normalizeValue, noteKey, noteKeys, radian, rawValue, stepValue, styleHelper, toFixed, xor } from "@tremolo-ui/functions";
-import { NOT_SUPPORTED, PERMISSION_DENIED, createDrag, createMIDIAccess, createMIDIInput, createMIDIMessage, createWheel } from "@tremolo-ui/dom";
-import { createStore, useStore } from "zustand";
-//#region src/components/AnimationCanvas/canvas.ts
-const drawingState = [
-	"strokeStyle",
-	"fillStyle",
-	"globalAlpha",
-	"lineWidth",
-	"lineCap",
-	"lineJoin",
-	"miterLimit",
-	"lineDashOffset",
-	"shadowOffsetX",
-	"shadowOffsetY",
-	"shadowBlur",
-	"shadowColor",
-	"globalCompositeOperation",
-	"font",
-	"textAlign",
-	"textBaseline",
-	"direction",
-	"imageSmoothingEnabled"
-];
-function setDprConfig(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
+import { applyDelta, blackKeyWidth, clamp, decimalPart, formatValue, getNoteRangeArray, isWhiteKey, linearScale, noteKey, notePosition, parseValue, pianoWidth, radian, styleHelper, toFixed, xor } from "@tremolo-ui/functions";
 //#region src/components/AnimationCanvas/index.tsx
-function AnimationCanvas({ draw, init, animate = true, options, width: _width = 100, height: _height = 100, relativeSize, reduceFlickering = true, className, onContextMenu = (event) => event.preventDefault(), ...props }) {
-	const canvasRef = useRef(null);
-	const memoCanvasRef = useRef(null);
-	const reqIdRef = useRef(-1);
-	const widthRef = useRef(0);
-	const heightRef = useRef(0);
-	const deltaMemoRef = useRef(-1);
-	const startTimeRef = useRef(-1);
-	const loop = useCallback((context, width, height, count) => {
-		const now = performance.now();
-		const deltaTime = now - deltaMemoRef.current;
-		const elapsedTime = now - startTimeRef.current;
-		deltaMemoRef.current = now;
-		if (animate) reqIdRef.current = requestAnimationFrame(() => loop(context, width, height, count + 1));
-		draw(context, {
-			width: width.current,
-			height: height.current,
-			count: count + 1,
-			deltaTime,
-			elapsedTime,
-			fps: 1e3 / deltaTime
+function AnimationCanvas({ draw, init, animate = true, options, width = 100, height = 100, relativeSize = false, reduceFlickering = true, className, onContextMenu = (event) => event.preventDefault(), ...props }) {
+	const [node, setNode] = useState(null);
+	const latest = useRef({
+		draw,
+		init,
+		animate,
+		width,
+		height,
+		reduceFlickering,
+		options
+	});
+	const instanceRef = useRef(null);
+	/** Set while the instance below is newer than the effect that pushes into it. */
+	const justCreated = useRef(false);
+	useEffect(() => {
+		if (!node) return;
+		const current = latest.current;
+		const instance = createAnimationCanvas(node, {
+			draw: (context, frame) => latest.current.draw(context, frame),
+			init: (context, size) => latest.current.init?.(context, size),
+			animate: current.animate,
+			size: {
+				width: current.width,
+				height: current.height
+			},
+			reduceFlickering: current.reduceFlickering,
+			relativeSize,
+			contextAttributes: current.options
 		});
-	}, [draw, animate]);
+		instanceRef.current = instance;
+		justCreated.current = true;
+		return () => {
+			instanceRef.current = null;
+			instance.destroy();
+		};
+	}, [node, relativeSize]);
 	useEffect(() => {
-		if (!canvasRef.current) return;
-		const canvas = canvasRef.current;
-		const context = canvas.getContext("2d", options);
-		if (!context) throw new Error("Cannot get canvas context.");
-		const dpr = globalThis.devicePixelRatio;
-		const firstRendering = (width, height) => {
-			setDprConfig(canvas, context, width, height, dpr);
-			widthRef.current = width;
-			heightRef.current = height;
-			if (init) init(context, {
-				width,
-				height
-			});
-			const now = performance.now();
-			deltaMemoRef.current = now;
-			startTimeRef.current = now;
-			loop(context, widthRef, heightRef, -1);
+		latest.current = {
+			draw,
+			init,
+			animate,
+			width,
+			height,
+			reduceFlickering,
+			options
 		};
-		if (relativeSize) {
-			const parent = canvas.parentElement;
-			if (!parent) throw new Error("Canvas doesn't have a parent element.");
-			const memoCanvas = memoCanvasRef.current;
-			const memoContext = memoCanvas?.getContext("2d", options);
-			const ro = new ResizeObserver((entries) => {
-				for (const entry of entries) {
-					const w = entry.contentRect.width;
-					const h = entry.contentRect.height;
-					const contextMemo = {};
-					if (reduceFlickering && memoCanvas && memoContext) {
-						for (const prop of drawingState) contextMemo[prop] = context[prop];
-						memoCanvas.width = w * dpr;
-						memoCanvas.height = h * dpr;
-						memoContext.scale(1 / dpr, 1 / dpr);
-						if (canvas.width > 0 && canvas.height > 0) memoContext.drawImage(canvas, 0, 0);
-					}
-					setDprConfig(canvas, context, w, h, dpr);
-					widthRef.current = w;
-					heightRef.current = h;
-					if (reduceFlickering && memoContext && memoCanvas && memoCanvas.width > 0 && memoCanvas.height > 0) {
-						for (const prop of drawingState) context[prop] = contextMemo[prop];
-						context.drawImage(memoContext.canvas, 0, 0);
-					}
-					if (!animate) loop(context, widthRef, heightRef, -1);
-				}
-			});
-			ro.observe(parent);
-			const width = parent.clientWidth;
-			const height = parent.clientHeight;
-			firstRendering(width, height);
-			return () => {
-				if (reqIdRef.current) cancelAnimationFrame(reqIdRef.current);
-				ro.disconnect();
-			};
-		} else {
-			const { width, height } = canvas.getBoundingClientRect();
-			firstRendering(width, height);
-			return () => {
-				if (reqIdRef.current) cancelAnimationFrame(reqIdRef.current);
-			};
+		if (justCreated.current) {
+			justCreated.current = false;
+			return;
 		}
-	}, [
-		loop,
-		init,
-		options,
-		reduceFlickering,
-		relativeSize,
-		animate
-	]);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("canvas", {
+		instanceRef.current?.update({
+			animate,
+			size: {
+				width,
+				height
+			},
+			reduceFlickering
+		});
+	});
+	return /* @__PURE__ */ jsx("canvas", {
 		className: clsx("tremolo-animation-canvas", className),
-		width: relativeSize ? 0 : _width,
-		height: relativeSize ? 0 : _height,
-		ref: canvasRef,
+		ref: setNode,
 		onContextMenu,
 		...props
-	}), relativeSize && reduceFlickering && /* @__PURE__ */ jsx("canvas", {
-		style: { display: "none" },
-		ref: memoCanvasRef
-	})] });
+	});
 }
 //#endregion
-//#region src/hooks/useCallbackRef.ts
+//#region src/hooks/_internal/useCallbackRef.ts
 /**
 * Internal
 * @private
@@ -155,36 +86,71 @@ function useCallbackRef(callback, deps = []) {
 	return useCallback((...args) => callbackRef.current?.(...args), deps);
 }
 //#endregion
-//#region src/hooks/useDrag.ts
+//#region src/hooks/useDragValue.ts
 /**
-* Track a pointer drag on an element.
+* Drive a value with a pointer drag.
 *
-* @returns a ref callback to attach to the element being dragged
+* @returns a ref callback for the element that starts the drag, and whether a drag is in progress
 */
-function useDrag({ threshold = 1, cursor, onDrag, onDragStart, onDragEnd }) {
-	const dragHandler = useCallbackRef(onDrag);
-	const dragStartHandler = useCallbackRef(onDragStart);
-	const dragEndHandler = useCallbackRef(onDragEnd);
+function useDragValue(options) {
+	const { axis, baseElementRef, pixelRange, updateOnPointerDown, threshold, cursor } = options;
+	if (!baseElementRef && !options.getValue) throw new Error("useDragValue: give either baseElementRef or getValue, so that the drag has something to move");
+	const [dragging, setDragging] = useState(false);
+	const valueGetter = useCallbackRef(options.getValue);
+	const changeHandler = useCallbackRef(options.onChange);
+	const dragStartHandler = useCallbackRef(options.onDragStart);
+	const dragEndHandler = useCallbackRef(options.onDragEnd);
+	const latest = useRef(options);
+	const instanceRef = useRef(null);
 	const [node, setNode] = useState(null);
+	const [pixelRangeX, pixelRangeY] = Array.isArray(pixelRange) ? pixelRange : [pixelRange, pixelRange];
 	useEffect(() => {
 		if (!node) return;
-		const instance = createDrag(node, {
-			threshold,
-			cursor,
-			onDragStart: () => dragStartHandler(),
-			onDrag: ({ x, y, deltaX, deltaY }) => dragHandler(x, y, deltaX, deltaY),
-			onDragEnd: () => dragEndHandler()
+		const instance = createDragValue(node, {
+			axis: latest.current.axis,
+			mapping: baseElementRef ? elementMapping(() => baseElementRef.current) : relativeMapping({ pixelRange: [pixelRangeX ?? 100, pixelRangeY ?? 100] }),
+			getValue: () => valueGetter() ?? [0, 0],
+			updateOnPointerDown: latest.current.updateOnPointerDown,
+			threshold: latest.current.threshold,
+			cursor: latest.current.cursor,
+			onChange: (value) => changeHandler(value),
+			onDragStart: (value) => {
+				setDragging(true);
+				dragStartHandler(value);
+			},
+			onDragEnd: (value) => {
+				setDragging(false);
+				dragEndHandler(value);
+			}
 		});
-		return () => instance.destroy();
+		instanceRef.current = instance;
+		return () => {
+			instanceRef.current = null;
+			instance.destroy();
+		};
 	}, [
 		node,
-		threshold,
-		cursor,
-		dragHandler,
+		baseElementRef,
+		pixelRangeX,
+		pixelRangeY,
+		valueGetter,
+		changeHandler,
 		dragStartHandler,
 		dragEndHandler
 	]);
-	return setNode;
+	useEffect(() => {
+		latest.current = options;
+		instanceRef.current?.update({
+			axis,
+			updateOnPointerDown,
+			threshold,
+			cursor
+		});
+	});
+	return {
+		refCallback: setNode,
+		dragging
+	};
 }
 //#endregion
 //#region src/hooks/useWheel.ts
@@ -193,16 +159,22 @@ function useDrag({ threshold = 1, cursor, onDrag, onDragStart, onDragEnd }) {
 *
 * The listener is not passive, so the handler may call `preventDefault()`.
 *
-* @returns a ref callback to attach to the element
+* @returns a ref callback to attach to the element, unused when `target` is given
 */
-function useWheel(onWheel) {
+function useWheel(onWheel, { requireFocus = false, target } = {}) {
 	const wheelHandler = useCallbackRef(onWheel);
 	const [node, setNode] = useState(null);
 	useEffect(() => {
-		if (!node) return;
-		const instance = createWheel(node, (event) => wheelHandler(event));
+		const element = target ? target.current : node;
+		if (!element) return;
+		const instance = createWheel(element, (event) => wheelHandler(event), { requireFocus });
 		return () => instance.destroy();
-	}, [node, wheelHandler]);
+	}, [
+		node,
+		target,
+		wheelHandler,
+		requireFocus
+	]);
 	return setNode;
 }
 //#endregion
@@ -213,68 +185,92 @@ function addUserSelectNone() {
 function removeUserSelectNone() {
 	window.document.body.classList.remove("tremolo-user-select-none");
 }
-function calcDrawingState({ value, min, max, skew, startValue, angleRange }) {
-	const p = normalizeValue(value, min, max, skew);
-	const s = normalizeValue(startValue, min, max, skew);
+//#endregion
+//#region src/components/_util/composeRefs.tsx
+/**
+* Set a given ref to a given value
+* This utility takes care of different types of refs: callback refs and RefObject(s)
+*/
+function setRef(ref, value) {
+	if (typeof ref === "function") return ref(value);
+	else if (ref !== null && ref !== void 0) ref.current = value;
+}
+/**
+* A utility to compose multiple refs together
+* Accepts callback refs and RefObject(s)
+*/
+function composeRefs(...refs) {
+	return (node) => {
+		let hasCleanup = false;
+		const cleanups = refs.map((ref) => {
+			const cleanup = setRef(ref, node);
+			if (!hasCleanup && typeof cleanup == "function") hasCleanup = true;
+			return cleanup;
+		});
+		if (hasCleanup) return () => {
+			for (let i = 0; i < cleanups.length; i++) {
+				const cleanup = cleanups[i];
+				if (typeof cleanup == "function") cleanup();
+				else setRef(refs[i], null);
+			}
+		};
+	};
+}
+/**
+* A custom hook that composes multiple refs
+* Accepts callback refs and RefObject(s)
+*/
+function useComposedRefs(...refs) {
+	return useCallback(composeRefs(...refs), refs);
+}
+/**
+* 角度から円弧上の点を求める。
+*
+* 半径は線の太さの分だけ内側に取る必要があるが、太さは ActiveLine / InactiveLine が
+* それぞれ持つため、座標はストアで先に計算せず各コンポーネント側で求める。
+*/
+function pointOnArc(angle, radius) {
+	return {
+		x: 50 + radius * Math.cos(radian(angle - 90)),
+		y: 50 + radius * Math.sin(radian(angle - 90))
+	};
+}
+/** 線の太さが viewBox からはみ出さないようにした半径 */
+function arcRadius(strokeWidth) {
+	const width = typeof strokeWidth === "number" ? strokeWidth : Number.parseFloat(String(strokeWidth));
+	return Number.isFinite(width) ? 50 - width / 2 : 50;
+}
+/** 設定から描画に必要な角度を導出する。レンダー中に呼ぶ。 */
+function calcAngles({ value, min, max, scale, startValue, angleRange }) {
+	const p = scale.normalize(value, min, max);
+	const s = scale.normalize(startValue, min, max);
 	const r1 = -angleRange / 2;
-	const r2 = r1 + Math.min(p, s) * angleRange;
-	const r3 = r1 + Math.max(p, s) * angleRange;
-	const r4 = angleRange / 2;
 	return {
 		p,
 		r1,
-		r2,
-		r3,
-		r4,
-		x1: 50 + 50 * Math.cos(radian(r1 - 90)),
-		y1: 50 + 50 * Math.sin(radian(r1 - 90)),
-		x2: 50 + 50 * Math.cos(radian(r2 - 90)),
-		y2: 50 + 50 * Math.sin(radian(r2 - 90)),
-		x3: 50 + 50 * Math.cos(radian(r3 - 90)),
-		y3: 50 + 50 * Math.sin(radian(r3 - 90)),
-		x4: 50 + 50 * Math.cos(radian(r4 - 90)),
-		y4: 50 + 50 * Math.sin(radian(r4 - 90))
+		r2: r1 + Math.min(p, s) * angleRange,
+		r3: r1 + Math.max(p, s) * angleRange,
+		r4: angleRange / 2
 	};
 }
-const createKnobStore = (initProps) => {
-	return createStore()(() => ({
-		...initProps,
-		...calcDrawingState(initProps)
-	}));
-};
 const KnobContext = createContext(null);
-function KnobProvider({ children, ...props }) {
-	const storeRef = useRef(null);
-	if (!storeRef.current) storeRef.current = createKnobStore(props);
-	useEffect(() => {
-		if (storeRef.current) storeRef.current.setState({
-			...props,
-			...calcDrawingState(props)
-		});
-		else storeRef.current = createKnobStore(props);
-	}, [props]);
-	return /* @__PURE__ */ jsx(KnobContext.Provider, {
-		value: storeRef.current,
-		children
-	});
-}
+const KnobProvider = KnobContext.Provider;
 function useKnobContext(selector) {
-	const store = useContext(KnobContext);
-	if (!store) throw new Error("Missing KnobContext.Provider in the tree");
-	return useStore(store, selector);
+	const context = useContext(KnobContext);
+	if (!context) throw new Error("Missing KnobContext.Provider in the tree");
+	return selector ? selector(context) : context;
 }
 //#endregion
 //#region src/components/Knob/ActiveLine.tsx
 function ActiveLine({ stroke = "currentColor", strokeWidth = 6, className, ...props }) {
 	const r2 = useKnobContext((s) => s.r2);
 	const r3 = useKnobContext((s) => s.r3);
-	const x2 = useKnobContext((s) => s.x2);
-	const y2 = useKnobContext((s) => s.y2);
-	const x3 = useKnobContext((s) => s.x3);
-	const y3 = useKnobContext((s) => s.y3);
+	const radius = arcRadius(strokeWidth);
+	const start = pointOnArc(r2, radius);
+	const end = pointOnArc(r3, radius);
 	return /* @__PURE__ */ jsx("path", {
 		className: clsx("tremolo-knob-active-line", className),
-		d: `M ${x2} ${y2} A 50 50 -135 ${r3 - r2 > 180 ? 1 : 0} 1 ${x3} ${y3}`,
+		d: `M ${start.x} ${start.y} A ${radius} ${radius} -135 ${r3 - r2 > 180 ? 1 : 0} 1 ${end.x} ${end.y}`,
 		fill: "none",
 		stroke,
 		strokeWidth,
@@ -291,24 +287,21 @@ function InactiveLine({ stroke = "currentColor", strokeWidth = 6, className, ...
 	const r2 = useKnobContext((s) => s.r2);
 	const r3 = useKnobContext((s) => s.r3);
 	const r4 = useKnobContext((s) => s.r4);
-	const x1 = useKnobContext((s) => s.x1);
-	const y1 = useKnobContext((s) => s.y1);
-	const x2 = useKnobContext((s) => s.x2);
-	const y2 = useKnobContext((s) => s.y2);
-	const x3 = useKnobContext((s) => s.x3);
-	const y3 = useKnobContext((s) => s.y3);
-	const x4 = useKnobContext((s) => s.x4);
-	const y4 = useKnobContext((s) => s.y4);
+	const radius = arcRadius(strokeWidth);
+	const p1 = pointOnArc(r1, radius);
+	const p2 = pointOnArc(r2, radius);
+	const p3 = pointOnArc(r3, radius);
+	const p4 = pointOnArc(r4, radius);
 	return /* @__PURE__ */ jsxs(Fragment, { children: [startValue > min && /* @__PURE__ */ jsx("path", {
 		className: clsx("tremolo-knob-inactive-line", className),
-		d: `M ${x1} ${y1} A 50 50 -135 ${r2 - r1 > 180 ? 1 : 0} 1 ${x2} ${y2}`,
+		d: `M ${p1.x} ${p1.y} A ${radius} ${radius} -135 ${r2 - r1 > 180 ? 1 : 0} 1 ${p2.x} ${p2.y}`,
 		fill: "none",
 		stroke,
 		strokeWidth,
 		...props
 	}), startValue < max && /* @__PURE__ */ jsx("path", {
 		className: clsx("tremolo-knob-inactive-line", className),
-		d: `M ${x3} ${y3} A 50 50 -135 ${r4 - r3 > 180 ? 1 : 0} 1 ${x4} ${y4}`,
+		d: `M ${p3.x} ${p3.y} A ${radius} ${radius} -135 ${r4 - r3 > 180 ? 1 : 0} 1 ${p4.x} ${p4.y}`,
 		fill: "none",
 		stroke,
 		strokeWidth,
@@ -316,6 +309,19 @@ function InactiveLine({ stroke = "currentColor", strokeWidth = 6, className, ...
 	})] });
 }
 //#endregion
+//#region src/components/Knob/SVGRoot.tsx
+function SVGRoot({ children, style, ...props }) {
+	return /* @__PURE__ */ jsx("svg", {
+		viewBox: `0 0 100 100`,
+		style: {
+			display: "block",
+			...style
+		},
+		...props,
+		children
+	});
+}
+//#endregion
 //#region src/components/Knob/Thumb.tsx
 function Thumb$2({ className, thumb = "currentColor", thumbLine = "currentColor", thumbSize = 84, thumbLineWeight = 6, thumbLineLength = 35, classes, ...props }) {
 	const angleRange = useKnobContext((s) => s.angleRange);
@@ -345,63 +351,36 @@ function Thumb$2({ className, thumb = "currentColor", thumbLine = "currentColor"
 	});
 }
 //#endregion
-//#region src/components/Knob/SVGRoot.tsx
-function SVGRoot({ children, style, ...props }) {
-	return /* @__PURE__ */ jsx("svg", {
-		viewBox: `0 0 100 100`,
-		style: {
-			display: "block",
-			overflow: "visible",
-			...style
-		},
-		...props,
-		children: children || /* @__PURE__ */ jsxs(Fragment, { children: [
-			/* @__PURE__ */ jsx(InactiveLine, {}),
-			/* @__PURE__ */ jsx(ActiveLine, {}),
-			/* @__PURE__ */ jsx(Thumb$2, {})
-		] })
-	});
-}
-//#endregion
 //#region src/components/Knob/index.tsx
-const defaultExternalStyles$3 = {
+const defaultExternalStyles$2 = {
 	userSelectNone: true,
 	cursor: "grabbing"
 };
 /**
+* The wheel only acts while the focus is inside, so that scrolling a page past
+* the control does not change its value.
+*/
+const WHEEL_OPTIONS$2 = { requireFocus: true };
+/**
 * Interactive rotary knob component implemented in SVG.
 */
 const Knob = {
-	Root: forwardRef(({ value, min, max, step = 1, skew = 1, defaultValue = min, startValue = min, size, externalStyles: _externalStyles, wheel = ["raw", 1], keyboard = ["raw", 1], enableDoubleClickDefault = true, disabled = false, readonly = false, angleRange = 270, onChange, onKeyDown, onPointerDown, onDoubleClick, className, style, children, ...props }, forwardedRef) => {
-		const [dragging, setDragging] = useState(false);
-		const valueRef = useRef(0);
+	Root: forwardRef(({ value, min, max, step = 1, scale = linearScale, defaultValue = min, startValue = min, size, externalStyles: _externalStyles, wheel = ["raw", 1], keyboard = ["raw", 1], enableDoubleClickDefault = true, disabled = false, readonly = false, angleRange = 270, onChange, onKeyDown, onPointerDown, onDoubleClick, className, style, children, ...props }, forwardedRef) => {
 		const elmRef = useRef(null);
 		const externalStyles = {
-			...defaultExternalStyles$3,
+			...defaultExternalStyles$2,
 			..._externalStyles
 		};
-		const onDrag = useCallback((_x, y) => {
-			if (!onChange || readonly) return;
-			onChange(clamp(stepValue(rawValue(valueRef.current - y / 100, min, max, skew), step), min, max));
-		}, [
-			max,
+		const range = useMemo(() => ({
 			min,
-			onChange,
-			readonly,
-			skew,
-			step
-		]);
-		const updateValueByEvent = useCallback((eventType, x) => {
-			let newValue;
-			if (eventType == "normalized") newValue = rawValue(normalizeValue(value, min, max, skew) + x, min, max, skew);
-			else newValue = value + x;
-			return clamp(stepValue(newValue, step), min, max);
-		}, [
 			max,
+			step,
+			scale
+		}), [
 			min,
-			skew,
+			max,
 			step,
-			value
+			scale
 		]);
 		const handleKeyDown = useCallback((event) => {
 			if (!keyboard || !onChange || readonly) return;
@@ -413,35 +392,63 @@ const Knob = {
 				"ArrowDown"
 			].includes(key)) {
 				event.preventDefault();
-				const x = key == "ArrowRight" || key == "ArrowUp" ? keyboard[1] : -keyboard[1];
-				onChange(updateValueByEvent(keyboard[0], x));
+				onChange(applyDelta(value, key == "ArrowRight" || key == "ArrowUp" ? 1 : -1, keyboard, range));
 			}
 		}, [
 			keyboard,
 			onChange,
 			readonly,
-			updateValueByEvent
+			value,
+			range
 		]);
-		const dragRefCallback = useDrag({
+		const { refCallback: dragRefCallback, dragging } = useDragValue({
+			axis: useMemo(() => [range, {
+				...range,
+				reverse: true
+			}], [range]),
+			getValue: () => [value, value],
+			threshold: 1,
 			cursor: readonly ? void 0 : externalStyles.cursor,
-			onDrag,
+			onChange: (v) => {
+				if (readonly) return;
+				onChange?.(v[1]);
+			},
 			onDragStart: () => {
-				setDragging(true);
-				valueRef.current = normalizeValue(value, min, max, skew);
 				if (externalStyles.userSelectNone) addUserSelectNone();
 			},
 			onDragEnd: () => {
-				setDragging(false);
 				if (externalStyles.userSelectNone) removeUserSelectNone();
 			}
 		});
-		const wheelRefCallback = useWheel((event) => {
+		const rootRefCallback = useComposedRefs(elmRef, dragRefCallback, useWheel((event) => {
 			if (!wheel || readonly) return;
 			event.preventDefault();
 			if (!onChange || event.deltaY == 0) return;
-			const x = Math.sign(event.deltaY) * -wheel[1];
-			onChange(updateValueByEvent(wheel[0], x));
-		});
+			onChange(applyDelta(value, -Math.sign(event.deltaY), wheel, range));
+		}, WHEEL_OPTIONS$2));
+		const context = useMemo(() => {
+			const config = {
+				value,
+				min,
+				max,
+				step,
+				scale,
+				startValue,
+				angleRange
+			};
+			return {
+				...config,
+				...calcAngles(config)
+			};
+		}, [
+			value,
+			min,
+			max,
+			step,
+			scale,
+			startValue,
+			angleRange
+		]);
 		useImperativeHandle(forwardedRef, () => {
 			return {
 				focus() {
@@ -453,19 +460,9 @@ const Knob = {
 			};
 		}, []);
 		return /* @__PURE__ */ jsx(KnobProvider, {
-			value,
-			min,
-			max,
-			step,
-			skew,
-			startValue,
-			angleRange,
+			value: context,
 			children: /* @__PURE__ */ jsx("div", {
-				ref: (elm) => {
-					elmRef.current = elm;
-					wheelRefCallback(elm);
-					dragRefCallback(elm);
-				},
+				ref: rootRefCallback,
 				className: clsx("tremolo-knob", className),
 				tabIndex: 0,
 				role: "slider",
@@ -490,7 +487,7 @@ const Knob = {
 					onKeyDown?.(event);
 				},
 				...props,
-				children: children || /* @__PURE__ */ jsx(SVGRoot, {})
+				children
 			})
 		});
 	}),
@@ -500,121 +497,18 @@ const Knob = {
 	Thumb: Thumb$2
 };
 //#endregion
-//#region src/components/NumberInput/type.ts
-function selectUnit(units, value) {
-	let i = 0;
-	for (; i < units.length; i++) if (Math.abs(units[i][1]) > Math.abs(value)) break;
-	return units[Math.max(0, i - 1)];
-}
-function parseValue(inputString, units, digit) {
-	const str = inputString.trim();
-	if (!units || typeof units == "string") {
-		const m = str.match(/-?\d+(\.\d+)?/);
-		let v = Number(m?.[0] ?? "0");
-		v = isNaN(v) ? 0 : v;
-		return {
-			rawValue: v,
-			formatValue: (digit != void 0 ? v.toFixed(digit) : v) + (units ?? ""),
-			unit: units ?? ""
-		};
-	}
-	const unitList = units.map(([u, _s]) => u);
-	const scaleList = units.map(([_u, s]) => s);
-	let rawValue = 0;
-	let unit = unitList[0];
-	let formatValue = (digit != void 0 ? rawValue.toFixed(digit) : rawValue) + unit;
-	const m = str.match(/^(-?\d+(\.\d+)?)\s*(\w*)$/);
-	if (m) {
-		rawValue = Number(m[1]) || 0;
-		const uIndex = unitList.indexOf(m[3]);
-		rawValue *= uIndex != -1 ? scaleList[uIndex] : 1;
-		const [u, scale] = selectUnit(units, rawValue);
-		const v = rawValue / scale;
-		formatValue = (digit != void 0 ? v.toFixed(digit) : v) + u;
-		unit = u;
-	}
-	return {
-		rawValue,
-		formatValue,
-		unit
-	};
-}
-//#endregion
 //#region src/components/NumberInput/context.tsx
-function safeClamp(value, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
-	return clamp(value, min, max);
-}
-const createNumberInputStore = (initProps) => {
-	const DEFAULT_PROPS = {
-		value: "",
-		valueAsNumber: 0,
-		min: 0,
-		max: 0,
-		step: 1,
-		readonly: false,
-		keepWithinRange: true,
-		onChange: (_v, _t) => {}
-	};
-	return createStore()((set) => ({
-		...DEFAULT_PROPS,
-		...initProps,
-		value: parseValue(String(initProps?.value || ""), initProps?.units, initProps?.digit).formatValue,
-		valueAsNumber: parseValue(String(initProps?.value || ""), initProps?.units, initProps?.digit).rawValue,
-		increment: () => set((state) => {
-			if (state.readonly) return {};
-			let next = parseValue(state.value, state.units, state.digit).rawValue + (state.step ?? 1);
-			if (state.keepWithinRange) next = safeClamp(next, state.min, state.max);
-			const v = parseValue(String(next), state.units, state.digit).formatValue;
-			state?.onChange?.(next, v);
-			return {
-				value: v,
-				valueAsNumber: next
-			};
-		}),
-		decrement: () => set((state) => {
-			if (state.readonly) return {};
-			let next = parseValue(state.value, state.units, state.digit).rawValue - (state.step ?? 1);
-			if (state.keepWithinRange) next = safeClamp(next, state.min, state.max);
-			const v = parseValue(String(next), state.units, state.digit).formatValue;
-			state?.onChange?.(next, v);
-			return {
-				value: v,
-				valueAsNumber: next
-			};
-		}),
-		change: (value) => set((state) => {
-			if (state.readonly) return {};
-			const v = value ?? "";
-			return {
-				value: v,
-				valueAsNumber: parseValue(v, state.units, state.digit).rawValue
-			};
-		})
-	}));
-};
 const NumberInputContext = createContext(null);
-function NumberInputProvider({ children, ...props }) {
-	const storeRef = useRef(null);
-	if (!storeRef.current) storeRef.current = createNumberInputStore(props);
-	useEffect(() => {
-		if (storeRef.current) {
-			const parsed = parseValue(String(props?.value || ""), props?.units, props?.digit);
-			storeRef.current.setState({
-				...props,
-				value: parsed.formatValue,
-				valueAsNumber: parsed.rawValue
-			});
-		} else storeRef.current = createNumberInputStore(props);
-	}, [props]);
-	return /* @__PURE__ */ jsx(NumberInputContext.Provider, {
-		value: storeRef.current,
-		children
-	});
-}
+const NumberInputProvider = NumberInputContext.Provider;
 function useNumberInputContext(selector) {
-	const store = useContext(NumberInputContext);
-	if (!store) throw new Error("Missing NumberInputContext.Provider in the tree");
-	return useStore(store, selector);
+	const context = useContext(NumberInputContext);
+	if (!context) throw new Error("Missing NumberInputContext.Provider in the tree");
+	return selector ? selector(context) : context;
+}
+const StepperContext = createContext(null);
+const StepperProvider = StepperContext.Provider;
+function useStepperContext() {
+	return useContext(StepperContext);
 }
 //#endregion
 //#region src/hooks/useEventListener.ts
@@ -673,653 +567,554 @@ function useLongPress(callback, initialDelay = 500, interval = 40) {
 	}, [callback]);
 }
 //#endregion
-//#region src/components/NumberInput/DecrementStepper.tsx
-function DecrementStepper({ size = 12, children, className, ...props }) {
-	const min = useNumberInputContext((s) => s.min);
-	const valueAsNumber = useNumberInputContext((s) => s.valueAsNumber);
-	const readonly = useNumberInputContext((s) => s.readonly);
-	const keepWithinRange = useNumberInputContext((s) => s.keepWithinRange);
-	const press = useLongPress(useNumberInputContext((s) => s.decrement));
+//#region src/components/NumberInput/stepperButton.tsx
+/**
+* Shared body of `IncrementStepper` and `DecrementStepper`: the two differ only
+* in which way they move the value and which arrow they draw.
+*/
+function StepperButton({ direction, variant, icon, className, style, children, onPointerDown, ...props }) {
+	const { step, readonly, atMin, atMax, nudge } = useNumberInputContext();
+	const stepper = useStepperContext();
+	const press = useLongPress(useCallback(() => {
+		if (stepper?.draggingRef.current) return;
+		nudge(direction, ["raw", step]);
+	}, [
+		stepper,
+		nudge,
+		direction,
+		step
+	]));
 	return /* @__PURE__ */ jsx("div", {
-		className: clsx("tremolo-number-input-decrement-stepper", className),
+		className: clsx(`tremolo-number-input-${variant}-stepper`, className),
 		role: "button",
 		tabIndex: -1,
-		"aria-disabled": keepWithinRange && valueAsNumber <= (min ?? Number.MIN_SAFE_INTEGER),
+		"aria-label": direction > 0 ? "Increment" : "Decrement",
+		"aria-disabled": direction > 0 ? atMax : atMin,
 		"aria-readonly": readonly,
-		onPointerDown: press,
+		style,
+		onPointerDown: (event) => {
+			if (!readonly) press();
+			onPointerDown?.(event);
+		},
 		...props,
-		children: children || /* @__PURE__ */ jsx("svg", {
-			width: size,
-			height: size,
-			viewBox: "0 0 24 24",
-			fill: "none",
-			stroke: "currentColor",
-			strokeWidth: "2",
-			strokeLinecap: "round",
-			strokeLinejoin: "round",
-			children: /* @__PURE__ */ jsx("polyline", { points: "6 9 12 15 18 9" })
-		})
+		children: children ?? icon
+	});
+}
+function StepperArrow({ up }) {
+	return /* @__PURE__ */ jsx("svg", {
+		className: "tremolo-number-input-stepper-icon",
+		viewBox: "0 0 24 24",
+		fill: "none",
+		stroke: "currentColor",
+		strokeWidth: "2",
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		children: /* @__PURE__ */ jsx("polyline", { points: up ? "18 15 12 9 6 15" : "6 9 12 15 18 9" })
 	});
 }
 //#endregion
-//#region src/components/NumberInput/IncrementStepper.tsx
-function IncrementStepper({ size = 12, children, className, ...props }) {
-	const max = useNumberInputContext((s) => s.max);
-	const valueAsNumber = useNumberInputContext((s) => s.valueAsNumber);
-	const readonly = useNumberInputContext((s) => s.readonly);
-	const keepWithinRange = useNumberInputContext((s) => s.keepWithinRange);
-	const press = useLongPress(useNumberInputContext((s) => s.increment));
-	return /* @__PURE__ */ jsx("div", {
-		className: clsx("tremolo-number-input-increment-stepper", className),
-		role: "button",
-		tabIndex: -1,
-		"aria-disabled": keepWithinRange && valueAsNumber >= (max ?? Number.MAX_SAFE_INTEGER),
-		"aria-readonly": readonly,
-		onPointerDown: press,
-		...props,
-		children: children || /* @__PURE__ */ jsx("svg", {
-			width: size,
-			height: size,
-			viewBox: "0 0 24 24",
-			fill: "none",
-			stroke: "currentColor",
-			strokeWidth: "2",
-			strokeLinecap: "round",
-			strokeLinejoin: "round",
-			children: /* @__PURE__ */ jsx("polyline", { points: "18 15 12 9 6 15" })
-		})
+//#region src/components/NumberInput/DecrementStepper.tsx
+/** Lowers the value by one `step`, repeating while held. */
+function DecrementStepper(props) {
+	return /* @__PURE__ */ jsx(StepperButton, {
+		direction: -1,
+		variant: "decrement",
+		icon: /* @__PURE__ */ jsx(StepperArrow, { up: false }),
+		...props
 	});
 }
 //#endregion
-//#region src/components/NumberInput/InternalInput.tsx
-const InternalInput = forwardRef(({ disabled, readonly, selectWithFocus, blurOnEnter, clampValueOnBlur, wheel, keyboard, className, onChange, onFocus, onBlur, onKeyDown, children: _children, ...props }, ref) => {
-	const elmRef = useRef(null);
-	const [editing, setEditing] = useState(false);
-	const value = useNumberInputContext((s) => s.value);
-	const valueAsNumber = useNumberInputContext((s) => s.valueAsNumber);
-	const min = useNumberInputContext((s) => s.min);
-	const max = useNumberInputContext((s) => s.max);
-	const step = useNumberInputContext((s) => s.step);
-	const units = useNumberInputContext((s) => s.units);
-	const digit = useNumberInputContext((s) => s.digit);
-	const change = useNumberInputContext((s) => s.change);
-	const error = useMemo(() => {
-		if (editing) return false;
-		const v = valueAsNumber;
-		return (min ?? -Infinity) > v || v > (max ?? Infinity);
-	}, [
-		editing,
-		max,
-		min,
-		valueAsNumber
-	]);
-	const updateValueByEvent = useCallback((eventType, x) => {
-		let newValue;
-		if (eventType == "normalized") {
-			if (!min || !max) throw new Error("[NumberInput] \"min\" and \"max\" are required when InputEventOption[0] is set to \"normalized\".");
-			newValue = rawValue(normalizeValue(valueAsNumber, min, max) + x, min, max);
-			return clamp(stepValue(newValue, step), min, max);
-		} else {
-			newValue = valueAsNumber + x;
-			return stepValue(newValue, step);
-		}
-	}, [
-		max,
-		min,
-		step,
-		valueAsNumber
-	]);
-	const handleKeyDown = useCallback((event) => {
-		if (!keyboard || !onChange || readonly) return;
-		const key = event.key;
-		if (!["ArrowUp", "ArrowDown"].includes(key)) return;
-		event.preventDefault();
-		const x = key == "ArrowUp" ? keyboard[1] : -keyboard[1];
-		const parsed = parseValue(String(updateValueByEvent(keyboard[0], x)));
-		onChange?.(parsed.rawValue, parsed.formatValue);
-	}, [
-		keyboard,
-		readonly,
-		onChange,
-		updateValueByEvent
-	]);
-	const wheelRefCallback = useWheel((event) => {
-		if (!wheel || readonly) return;
-		event.preventDefault();
-		if (!onChange || event.deltaY == 0) return;
-		const x = Math.sign(event.deltaY) * -wheel[1];
-		const parsed = parseValue(String(updateValueByEvent(wheel[0], x)));
-		onChange?.(parsed.rawValue, parsed.formatValue);
+//#region src/components/NumberInput/IncrementStepper.tsx
+/** Raises the value by one `step`, repeating while held. */
+function IncrementStepper(props) {
+	return /* @__PURE__ */ jsx(StepperButton, {
+		direction: 1,
+		variant: "increment",
+		icon: /* @__PURE__ */ jsx(StepperArrow, { up: true }),
+		...props
 	});
-	useImperativeHandle(ref, () => {
-		return {
-			focus() {
-				elmRef.current?.focus();
-			},
-			blur() {
-				elmRef.current?.blur();
-			}
-		};
-	}, []);
+}
+//#endregion
+//#region src/components/NumberInput/InputField.tsx
+/** The leading number of the displayed text, whatever the format put around it. */
+const NUMBER_PREFIX = /^\s*-?[\d.,]*/;
+/**
+* The text field of a `NumberInput`, and the only place the value can be typed.
+*
+* While the user types, their own text stands rather than `format(value)`, so
+* that a half-finished entry is not rewritten under the caret.
+*/
+function InputField({ selectOnFocus = "none", blurOnEnter = true, className, style, ref, onFocus, onBlur, onKeyDown, ...props }) {
+	const { value, min, max, step, disabled, readonly, keyboard, text, outOfRange, setDraft, commitDraft, nudge, inputRef } = useNumberInputContext();
 	return /* @__PURE__ */ jsx("input", {
-		ref: (input) => {
-			elmRef.current = input;
-			wheelRefCallback(input);
-		},
-		className: clsx("tremolo-number-input", className),
-		value,
-		min,
-		max,
-		step,
+		ref: useComposedRefs(ref, inputRef),
+		className: clsx("tremolo-number-input-field", className),
 		type: "text",
+		inputMode: "decimal",
+		role: "spinbutton",
+		value: text,
+		readOnly: readonly,
 		"aria-disabled": disabled,
 		"aria-readonly": readonly,
-		tabIndex: -1,
-		"data-error": error,
-		onChange: (event) => {
-			if (readonly) return;
-			const v = event.currentTarget.value;
-			const cursorPos = event.target.selectionStart;
-			change(v);
-			const valueAsNumber = parseValue(v, units, digit).rawValue;
-			onChange?.(valueAsNumber, v);
-			if (cursorPos) {
-				event.target.selectionStart = cursorPos;
-				event.target.selectionEnd = cursorPos;
-			}
-		},
+		"aria-valuenow": value,
+		"aria-valuemin": min,
+		"aria-valuemax": max,
+		"aria-valuetext": text,
+		step,
+		"data-out-of-range": outOfRange,
+		style,
+		onChange: (event) => setDraft(event.currentTarget.value),
 		onFocus: (event) => {
-			setEditing(true);
-			const v = event.currentTarget.value;
-			const parsed = parseValue(v, units, digit);
-			if (selectWithFocus == "all") event.currentTarget.setSelectionRange(0, v.length);
-			else if (selectWithFocus == "number") event.currentTarget.setSelectionRange(0, parsed.formatValue.length - parsed.unit.length);
-			onFocus?.(parsed.rawValue, parsed.formatValue, event);
+			const input = event.currentTarget;
+			if (selectOnFocus == "all") input.setSelectionRange(0, input.value.length);
+			else if (selectOnFocus == "number") input.setSelectionRange(0, input.value.match(NUMBER_PREFIX)?.[0].length ?? 0);
+			onFocus?.(event);
 		},
 		onBlur: (event) => {
-			setEditing(false);
-			let v = parseValue(event.currentTarget.value, units, digit).rawValue;
-			if (clampValueOnBlur) v = safeClamp(v, min, max);
-			const parsed = parseValue(String(v), units, digit);
-			change(parsed.formatValue);
-			if (clampValueOnBlur) onChange?.(parsed.rawValue, parsed.formatValue);
-			onBlur?.(parsed.rawValue, parsed.formatValue, event);
+			commitDraft();
+			onBlur?.(event);
 		},
 		onKeyDown: (event) => {
-			if (blurOnEnter && event.key == "Enter") event.currentTarget.blur();
-			handleKeyDown(event);
+			const key = event.key;
+			if (key == "Enter") {
+				commitDraft();
+				if (blurOnEnter) event.currentTarget.blur();
+			} else if (keyboard && !readonly && (key == "ArrowUp" || key == "ArrowDown")) {
+				event.preventDefault();
+				nudge(key == "ArrowUp" ? 1 : -1, keyboard);
+			}
 			onKeyDown?.(event);
 		},
 		...props
 	});
-});
+}
+//#endregion
+//#region src/hooks/useDrag.ts
+/**
+* Track a pointer drag on an element.
+*
+* @returns a ref callback to attach to the element being dragged
+*/
+function useDrag({ threshold = 1, cursor, onDrag, onDragStart, onDragEnd }) {
+	const dragHandler = useCallbackRef(onDrag);
+	const dragStartHandler = useCallbackRef(onDragStart);
+	const dragEndHandler = useCallbackRef(onDragEnd);
+	const [node, setNode] = useState(null);
+	useEffect(() => {
+		if (!node) return;
+		const instance = createDrag(node, {
+			threshold,
+			cursor,
+			onDragStart: () => dragStartHandler(),
+			onDrag: ({ x, y, deltaX, deltaY }) => dragHandler(x, y, deltaX, deltaY),
+			onDragEnd: () => dragEndHandler()
+		});
+		return () => instance.destroy();
+	}, [
+		node,
+		threshold,
+		cursor,
+		dragHandler,
+		dragStartHandler,
+		dragEndHandler
+	]);
+	return setNode;
+}
 //#endregion
 //#region src/components/NumberInput/Stepper.tsx
-function Stepper({ dynamic = true, children, className, ...props }) {
-	return /* @__PURE__ */ jsx("div", {
-		className: clsx("tremolo-number-input-stepper", className),
-		"data-dynamic": dynamic,
-		...props,
-		children
+/**
+* The area the steppers sit in, and a drag handle in its own right: dragging it
+* up and down moves the value one `step` every `drag` pixels.
+*
+* The drag lives here rather than on `InputField` because `createDrag` turns
+* off text selection on whatever element it is attached to.
+*/
+function Stepper({ className, style, children, ref, ...props }) {
+	const { value, step, readonly, drag, range, changeValue } = useNumberInputContext();
+	/**
+	* Set once the drag has actually moved the value, so that the press-and-hold
+	* repeat of a stepper stands down and leaves the value to the drag. A ref,
+	* because it is read from inside the repeat rather than rendered.
+	*/
+	const draggingRef = useRef(false);
+	/**
+	* Where the drag started, taken on the first move rather than on pointer
+	* down: the steppers act on pointer down, so by then the value may already
+	* have been nudged once, and the drag should carry on from there.
+	*/
+	const originRef = useRef(null);
+	const dragRefCallback = useDrag({
+		threshold: 1,
+		cursor: readonly ? void 0 : "ns-resize",
+		onDragStart: () => {
+			originRef.current = null;
+			draggingRef.current = false;
+		},
+		onDrag: (_x, y) => {
+			if (readonly || drag == null) return;
+			if (!originRef.current) {
+				originRef.current = {
+					y,
+					value
+				};
+				return;
+			}
+			const steps = Math.round(-(y - originRef.current.y) / drag);
+			if (steps == 0) return;
+			draggingRef.current = true;
+			changeValue(applyDelta(originRef.current.value, steps, ["raw", step], range));
+		},
+		onDragEnd: () => {
+			draggingRef.current = false;
+		}
+	});
+	const composedRef = useComposedRefs(ref, drag != null && !readonly ? dragRefCallback : void 0);
+	return /* @__PURE__ */ jsx(StepperProvider, {
+		value: useMemo(() => ({ draggingRef }), []),
+		children: /* @__PURE__ */ jsx("div", {
+			ref: composedRef,
+			className: clsx("tremolo-number-input-stepper", className),
+			style,
+			...props,
+			children
+		})
 	});
 }
 /**
 * Input with some useful functions for entering numerical values.
 */
 const NumberInput = {
-	Root: forwardRef(({ value, min, max, step = 1, units, readonly = false, disabled = false, digit, variant = "outline", selectWithFocus = "none", blurOnEnter = true, keepWithinRange = true, clampValueOnBlur = true, wheel = ["raw", 1], keyboard = ["raw", 1], activeColor, wrapperClassName, className, onChange, onFocus, onBlur, children, ...props }, forwardedRef) => {
-		const colors = { "--active-color": activeColor };
-		return /* @__PURE__ */ jsx(NumberInputProvider, {
-			value: String(value),
+	Root: forwardRef(({ value, min, max, step = 1, scale = linearScale, units, digit, format: formatProp, parse: parseProp, clampValue = true, wheel = ["raw", 1], keyboard = ["raw", 1], drag = 1, disabled = false, readonly = false, className, style, onChange, children, ...props }, forwardedRef) => {
+		const inputRef = useRef(null);
+		/**
+		* The text being typed. The only state here: it is not a copy of `value`,
+		* but the half-finished entry that has no value to be derived from yet.
+		*/
+		const [draft, setDraft] = useState(null);
+		const format = useCallback((v) => formatProp ? formatProp(v) : formatValue(v, units, digit), [
+			formatProp,
+			units,
+			digit
+		]);
+		const parse = useCallback((t) => parseProp ? parseProp(t) : parseValue(t, units), [parseProp, units]);
+		const range = useMemo(() => ({
+			min: (clampValue ? min : void 0) ?? Number.MIN_SAFE_INTEGER,
+			max: (clampValue ? max : void 0) ?? Number.MAX_SAFE_INTEGER,
+			step,
+			scale
+		}), [
+			clampValue,
 			min,
 			max,
 			step,
-			units,
-			digit,
+			scale
+		]);
+		const text = draft ?? format(value);
+		const editing = draft != null;
+		const outOfRange = !editing && (min != void 0 && value < min || max != void 0 && value > max);
+		const handleDraft = useCallback((next) => {
+			if (readonly) return;
+			setDraft(next);
+			const parsed = parse(next);
+			if (Number.isFinite(parsed)) onChange?.(parsed);
+		}, [
 			readonly,
-			keepWithinRange,
-			onChange,
-			children: /* @__PURE__ */ jsxs("div", {
-				className: clsx("tremolo-number-input-wrapper", wrapperClassName),
-				tabIndex: 0,
-				style: { ...colors },
-				"data-stepper": !!children,
-				"data-variant": variant,
-				children: [/* @__PURE__ */ jsx(InternalInput, {
-					ref: forwardedRef,
-					readonly,
-					disabled,
-					selectWithFocus,
-					blurOnEnter,
-					clampValueOnBlur,
-					wheel,
-					keyboard,
-					className,
-					onChange,
-					onFocus,
-					onBlur,
-					...props
-				}), children]
+			parse,
+			onChange
+		]);
+		const changeValue = useCallback((next) => {
+			if (readonly) return;
+			setDraft(null);
+			if (next != value) onChange?.(next);
+		}, [
+			readonly,
+			value,
+			onChange
+		]);
+		const commitDraft = useCallback(() => {
+			if (draft == null || readonly) return;
+			changeValue(clamp(parse(draft), range.min, range.max));
+		}, [
+			draft,
+			readonly,
+			parse,
+			range,
+			changeValue
+		]);
+		const nudge = useCallback((direction, option) => {
+			changeValue(applyDelta(value, direction, option, range));
+		}, [
+			changeValue,
+			value,
+			range
+		]);
+		const wheelRefCallback = useWheel((event) => {
+			if (!wheel || readonly || event.deltaY == 0) return;
+			event.preventDefault();
+			nudge(-Math.sign(event.deltaY), wheel);
+		}, { requireFocus: true });
+		const context = useMemo(() => ({
+			value,
+			min,
+			max,
+			step,
+			scale,
+			disabled,
+			readonly,
+			clampValue,
+			range,
+			keyboard,
+			text,
+			editing,
+			outOfRange,
+			atMin: clampValue && min != void 0 && value <= min,
+			atMax: clampValue && max != void 0 && value >= max,
+			drag,
+			format,
+			parse,
+			setDraft: handleDraft,
+			commitDraft,
+			changeValue,
+			nudge,
+			inputRef
+		}), [
+			value,
+			min,
+			max,
+			step,
+			scale,
+			disabled,
+			readonly,
+			clampValue,
+			range,
+			keyboard,
+			text,
+			editing,
+			outOfRange,
+			drag,
+			format,
+			parse,
+			handleDraft,
+			commitDraft,
+			changeValue,
+			nudge
+		]);
+		useImperativeHandle(forwardedRef, () => {
+			return {
+				focus() {
+					inputRef.current?.focus();
+				},
+				blur() {
+					inputRef.current?.blur();
+				}
+			};
+		}, []);
+		return /* @__PURE__ */ jsx(NumberInputProvider, {
+			value: context,
+			children: /* @__PURE__ */ jsx("div", {
+				ref: wheelRefCallback,
+				className: clsx("tremolo-number-input", className),
+				"aria-disabled": disabled,
+				"aria-readonly": readonly,
+				style,
+				...props,
+				children
 			})
 		});
 	}),
+	InputField,
 	Stepper,
 	IncrementStepper,
 	DecrementStepper
 };
 //#endregion
-//#region src/hooks/useRefCallbackEvent.ts
-function useRefCallbackEvent(event, handler, options, deps = []) {
-	return useMemo(() => {
-		let cleanup;
-		return (node) => {
-			if (!node) {
-				cleanup?.();
-				return;
-			}
-			node.addEventListener(event, handler, options);
-			cleanup = () => {
-				node.removeEventListener(event, handler, options);
-			};
-		};
-	}, deps);
-}
-//#endregion
-//#region src/hooks/usePianoDrag.ts
+//#region src/components/Piano/keyboardShortcuts.ts
 /**
-* Internal
-* @returns [refCallback, pointerDownHandler]
-* @private
+* Ready-made keyboard layouts. Both assume `noteRange.first` is a C.
 */
-function usePianoDrag({ baseElementRef, onDrag, onDragStart, onDragEnd }) {
-	const dragged = useRef(false);
-	const normalizedX = useRef(0);
-	const normalizedY = useRef(0);
-	const handleDrag = useCallback((event) => {
-		if (!baseElementRef.current || !dragged.current) return;
-		const isTouch = event instanceof TouchEvent;
-		if (isTouch && event.cancelable) event.preventDefault();
-		const { left, top, right, bottom } = baseElementRef.current.getBoundingClientRect();
-		const mouseX = isTouch ? event.touches[0].clientX : event.clientX;
-		const mouseY = isTouch ? event.touches[0].clientY : event.clientY;
-		const nx = normalizeValue(mouseX, left, right);
-		const ny = normalizeValue(mouseY, top, bottom);
-		normalizedX.current = nx;
-		normalizedY.current = ny;
-		onDrag(nx, ny);
-	}, [onDrag, baseElementRef]);
-	const refHandler = useRefCallbackEvent("touchmove", handleDrag, { passive: false }, [onDrag]);
-	const pointerDownHandler = useCallback((event) => {
-		dragged.current = true;
-		handleDrag(event);
-		onDragStart?.(normalizedX.current, normalizedY.current);
-	}, [handleDrag, onDragStart]);
-	useEventListener(globalThis.window, "pointermove", handleDrag);
-	useEventListener(globalThis.window, "pointerup", () => {
-		if (!dragged.current) return;
-		dragged.current = false;
-		onDragEnd?.(normalizedX.current, normalizedY.current);
-	});
-	return {
-		refHandler,
-		pointerDownHandler
-	};
-}
-//#endregion
-//#region src/components/Piano/context.tsx
-const createPianoStore = (initProps) => {
-	const DEFAULT_PROPS = {
-		noteRange: {
-			first: 0,
-			last: 127
-		},
-		glissando: true,
-		midiMax: 127,
-		fill: false,
-		label: () => void 0,
-		onPlayNote: () => {},
-		onStopNote: () => {}
-	};
-	return createStore()(() => ({
-		...DEFAULT_PROPS,
-		...initProps,
-		notePosition: initProps.notePosition
-	}));
+const SHORTCUTS = {
+	HOME_ROW: { keys: [
+		"a",
+		"w",
+		"s",
+		"e",
+		"d",
+		"f",
+		"t",
+		"g",
+		"y",
+		"h",
+		"u",
+		"j",
+		"k",
+		"o",
+		"l",
+		"p",
+		";"
+	] },
+	HOME_ROW_NATURAL: { keys: [
+		"a",
+		"",
+		"s",
+		"",
+		"d",
+		"f",
+		"",
+		"g",
+		"",
+		"h",
+		"",
+		"j",
+		"k",
+		"",
+		"l",
+		"",
+		";"
+	] }
 };
-const PianoContext = createContext(null);
-function PianoProvider({ children, ...props }) {
-	const storeRef = useRef(null);
-	if (!storeRef.current) storeRef.current = createPianoStore(props);
-	useEffect(() => {
-		if (storeRef.current) storeRef.current.setState(props);
-		else storeRef.current = createPianoStore(props);
-	}, [props]);
-	return /* @__PURE__ */ jsx(PianoContext.Provider, {
-		value: storeRef.current,
-		children
-	});
-}
-function usePianoContext(selector) {
-	const store = useContext(PianoContext);
-	if (!store) throw new Error("Missing PianoContext.Provider in the tree");
-	return useStore(store, selector);
-}
-//#endregion
-//#region src/components/Piano/KeyLabel.tsx
-function KeyLabel({ label, className, wrapperClassName, wrapperStyle, __note, __label, ...props }) {
-	const index = getNoteRangeArray(usePianoContext((s) => s.noteRange)).indexOf(__note);
-	const content = label ? label(__note, index) : __label && __label(__note, index);
-	return (content != void 0 || content != null) && /* @__PURE__ */ jsx("div", {
-		className: clsx("tremolo-piano-key-label-wrapper", wrapperClassName),
-		style: wrapperStyle,
-		children: /* @__PURE__ */ jsx("div", {
-			className: clsx("tremolo-piano-key-label", className),
-			...props,
-			children: content
-		})
+/**
+* Customizable piano component.
+*/
+const Piano = { Root: forwardRef(function Root({ noteRange, glissando = true, midiMax = 127, keyboardShortcuts, fill = false, whiteKeyWidth = 40, keyGap = 1, blackKeyWidthRatio = .65, blackKeyHeightRatio = .6, height = fill ? "100%" : 160, style, className, label, keyProps, onPlayNote, onStopNote, ...props }, forwardedRef) {
+	const [node, setNode] = useState(null);
+	const [activeNotes, setActiveNotes] = useState([]);
+	/** Set while `fill` is on, measured from the parent. */
+	const [filledKeyWidth, setFilledKeyWidth] = useState(whiteKeyWidth);
+	const notes = useMemo(() => getNoteRangeArray(noteRange), [noteRange]);
+	const whiteKeyCount = useMemo(() => notes.filter(isWhiteKey).length, [notes]);
+	const layout = useMemo(() => ({
+		noteRange,
+		whiteKeyWidth: fill ? filledKeyWidth : whiteKeyWidth,
+		keyGap,
+		blackKeyWidthRatio,
+		blackKeyHeightRatio
+	}), [
+		noteRange,
+		fill,
+		filledKeyWidth,
+		whiteKeyWidth,
+		keyGap,
+		blackKeyWidthRatio,
+		blackKeyHeightRatio
+	]);
+	const latest = useRef({
+		layout,
+		glissando,
+		midiMax,
+		onPlayNote,
+		onStopNote
 	});
-}
-const KeyImpl = forwardRef(({ keyType, noteNumber, width, height, bg, color, activeBg, activeColor, className, style, children, __width, ...props }, ref) => {
-	const [played, setPlayed] = useState(false);
-	const midiMax = usePianoContext((s) => s.midiMax);
-	const fill = usePianoContext((s) => s.fill);
-	const onPlayNote = usePianoContext((s) => s.onPlayNote);
-	const onStopNote = usePianoContext((s) => s.onStopNote);
-	const label = usePianoContext((s) => s.label);
-	const position = usePianoContext((s) => s.notePosition)(noteNumber);
-	const disabled = noteNumber > midiMax;
-	const colors = {
-		"--bg": bg,
-		"--color": color,
-		"--active-bg": activeBg,
-		"--active-color": activeColor
-	};
-	useImperativeHandle(ref, () => {
-		return {
-			play(velocity) {
-				if (disabled) return;
-				setPlayed(true);
-				if (onPlayNote) onPlayNote(noteNumber, velocity);
-			},
-			stop() {
-				setPlayed(false);
-				if (onStopNote) onStopNote(noteNumber);
-			},
-			played() {
-				return played;
-			}
+	const instanceRef = useRef(null);
+	useEffect(() => {
+		if (!node) return;
+		const instance = createPianoInput(node, {
+			layout: latest.current.layout,
+			glissando: latest.current.glissando,
+			midiMax: latest.current.midiMax,
+			onPlayNote: (note, velocity) => latest.current.onPlayNote?.(note, velocity),
+			onStopNote: (note) => latest.current.onStopNote?.(note),
+			onActiveNotesChange: setActiveNotes
+		});
+		instanceRef.current = instance;
+		return () => {
+			instanceRef.current = null;
+			instance.destroy();
 		};
+	}, [node]);
+	useEffect(() => {
+		latest.current = {
+			layout,
+			glissando,
+			midiMax,
+			onPlayNote,
+			onStopNote
+		};
+		instanceRef.current?.update({
+			layout,
+			glissando,
+			midiMax
+		});
+	});
+	useEffect(() => {
+		if (!fill || !node) return;
+		const parent = node.parentElement;
+		if (!parent) throw new Error("doesn't have a parent element.");
+		const resizeObserver = new ResizeObserver(() => {
+			setFilledKeyWidth(node.clientWidth / whiteKeyCount - keyGap);
+		});
+		resizeObserver.observe(parent);
+		return () => resizeObserver.disconnect();
 	}, [
-		disabled,
-		noteNumber,
-		onPlayNote,
-		onStopNote,
-		played
+		fill,
+		node,
+		whiteKeyCount,
+		keyGap
 	]);
-	let keyLabelProps = {};
-	if (children != void 0) React.Children.forEach(children, (child) => {
-		if (React.isValidElement(child)) if (child.type == KeyLabel) keyLabelProps = child.props;
-		else throw new Error("only <KeyLabel>");
-		else throw new Error("children is an invalid element.");
+	/** The note a shortcut key plays, or null when it has none. */
+	function shortcutNote(key) {
+		if (!keyboardShortcuts || key === "") return null;
+		const index = keyboardShortcuts.keys.indexOf(key);
+		return index === -1 ? null : noteRange.first + index;
+	}
+	useEventListener(globalThis.window, "keydown", (e) => {
+		if (e.repeat) return;
+		const note = shortcutNote(e.key);
+		if (note !== null) instanceRef.current?.noteOn(note, { source: "keyboard" });
+	});
+	useEventListener(globalThis.window, "keyup", (e) => {
+		const note = shortcutNote(e.key);
+		if (note !== null) instanceRef.current?.noteOff(note, { source: "keyboard" });
 	});
+	useImperativeHandle(forwardedRef, () => ({
+		playNote: (note, velocity) => instanceRef.current?.noteOn(note, {
+			source: "api",
+			velocity
+		}),
+		stopNote: (note) => instanceRef.current?.noteOff(note, { source: "api" })
+	}), []);
 	return /* @__PURE__ */ jsx("div", {
-		className: clsx(`tremolo-piano-${keyType}-key`, className),
-		"aria-disabled": disabled,
-		"data-active": played,
+		ref: setNode,
+		className: clsx("tremolo-piano", className),
 		style: {
-			...colors,
-			left: position,
-			width: fill ? __width : width,
+			width: fill ? "100%" : pianoWidth(layout),
 			height,
 			...style
 		},
 		...props,
-		children: /* @__PURE__ */ jsx(KeyLabel, {
-			label,
-			__note: noteNumber,
-			...keyLabelProps
-		})
-	});
-});
-const WhiteKey = forwardRef(({ width = 40, height = "100%", onContextMenu = (e) => e.preventDefault(), ...props }, ref) => {
-	return /* @__PURE__ */ jsx(KeyImpl, {
-		ref,
-		keyType: "white",
-		width,
-		height,
-		onContextMenu,
-		...props
-	});
-});
-const BlackKey = forwardRef(({ width = 26, height = "60%", onContextMenu = (e) => e.preventDefault(), ...props }, ref) => {
-	return /* @__PURE__ */ jsx(KeyImpl, {
-		ref,
-		keyType: "black",
-		width,
-		height,
-		onContextMenu,
-		...props
-	});
-});
-//#endregion
-//#region src/components/Piano/keyboardShortcuts.ts
-const SHORTCUTS = { HOME_ROW: { keys: [
-	"a",
-	"w",
-	"s",
-	"e",
-	"d",
-	"f",
-	"t",
-	"g",
-	"y",
-	"h",
-	"u",
-	"j",
-	"k",
-	"o",
-	"l",
-	"p",
-	";"
-] } };
-//#endregion
-//#region src/components/Piano/index.tsx
-/**
-* [noteRange.first, noteRange.first + 1 ..., noteRange.last]
-*/
-function getNoteRangeArray(noteRange) {
-	return Array.from({ length: noteRange.last - noteRange.first + 1 }, (_, i) => i + noteRange.first);
-}
-const blackPerWhiteWidth = 26 / 40;
-/**
-* Customizable piano component.
-*/
-const Piano = {
-	Root: forwardRef(({ noteRange, glissando = true, midiMax = 127, keyboardShortcuts, fill = false, height = fill ? "100%" : 160, whiteNoteWidth: _whiteNoteWidth = 40, style, className, onPlayNote, onStopNote, label, children, onPointerDown, ...props }, forwardedRef) => {
-		const [whiteNoteWidth, setWhiteNoteWidth] = useState(_whiteNoteWidth);
-		const keyRefs = useRef([]);
-		for (let i = 0; i < noteRange.last - noteRange.first + 1; i++) keyRefs.current[i] = createRef();
-		const pianoRef = useRef(null);
-		const hitKeyIndex = useRef(-1);
-		const noteRangeArray = getNoteRangeArray(noteRange);
-		const whiteNotes = noteRangeArray.filter((v) => isWhiteKey(v));
-		const blackNotes = noteRangeArray.filter((v) => isBlackKey(v));
-		const whiteNoteCount = whiteNotes.length;
-		const padding = 1;
-		const staticWidth = (whiteNoteWidth + padding) * whiteNoteCount;
-		const childrenWithProps = useMemo(() => {
-			return children && React.Children.map(children, (child, index) => {
-				if (React.isValidElement(child)) {
-					const __width = child.type == WhiteKey ? whiteNoteWidth : whiteNoteWidth * .65;
-					const props = {
-						ref: keyRefs.current[index],
-						__width
-					};
-					return React.cloneElement(child, props);
-				}
-				return child;
-			});
-		}, [children, whiteNoteWidth]);
-		const notePosition = useCallback((note) => {
-			const pitchPositions = {
-				C: 0,
-				"C#": 1,
-				D: 1,
-				"D#": 2,
-				E: 2,
-				F: 3,
-				"F#": 4,
-				G: 4,
-				"G#": 5,
-				A: 5,
-				"A#": 6,
-				B: 6
-			};
-			const blackNoteWidth = whiteNoteWidth * blackPerWhiteWidth;
-			const padding = 1;
-			const targetNoteKey = noteKey(note);
-			const firstNoteKey = noteKey(noteRange.first);
-			const octave = Math.floor((note - noteRange.first) / 12);
-			const octaveOffset = noteKeys.indexOf(firstNoteKey) > noteKeys.indexOf(targetNoteKey) ? 1 : 0;
-			const w = whiteNoteWidth + padding;
-			const pos = pitchPositions[targetNoteKey] - pitchPositions[firstNoteKey];
-			const blackKeyOffset = isBlackKey(note) ? blackNoteWidth / 2 : 0;
-			return pos * w + (octave + octaveOffset) * 7 * w - blackKeyOffset;
-		}, [noteRange.first, whiteNoteWidth]);
-		const getHitKeyIndex = useCallback((x, y) => {
-			if (!pianoRef.current) return -1;
-			const containerHeight = pianoRef.current.clientHeight;
-			const notes = [...blackNotes, ...whiteNotes];
-			for (let i = 0; i < notes.length; i++) {
-				const note = notes[i];
-				const pos = notePosition(note);
-				const w = isWhiteKey(note) ? whiteNoteWidth : whiteNoteWidth * blackPerWhiteWidth;
-				const h = isWhiteKey(note) ? containerHeight : containerHeight * .6;
-				if (pos <= x && x < pos + w && 0 <= y && y < h) return note;
-			}
-			return -1;
-		}, [
-			blackNotes,
-			notePosition,
-			whiteNoteWidth,
-			whiteNotes
-		]);
-		const onDrag = useCallback((perX, perY) => {
-			if (!pianoRef.current) return;
-			const note = getHitKeyIndex(perX * staticWidth, perY * pianoRef.current.clientHeight);
-			const index = noteRangeArray.indexOf(note);
-			if (index == -1) return;
-			if (hitKeyIndex.current != index) {
-				keyRefs.current[hitKeyIndex.current]?.current?.stop();
-				keyRefs.current[index]?.current?.play();
-				hitKeyIndex.current = index;
-			}
-		}, [
-			getHitKeyIndex,
-			noteRangeArray,
-			staticWidth
-		]);
-		const onDragEnd = useCallback(() => {
-			if (keyRefs.current[hitKeyIndex.current]?.current?.played()) keyRefs.current[hitKeyIndex.current]?.current?.stop();
-			hitKeyIndex.current = -1;
-		}, [keyRefs]);
-		useEffect(() => {
-			if (fill && pianoRef.current) {
-				const parent = pianoRef.current.parentElement;
-				if (!parent) throw new Error("doesn't have a parent element.");
-				const resizeObserver = new ResizeObserver(() => {
-					const w = pianoRef.current.clientWidth;
-					setWhiteNoteWidth(w / whiteNoteCount - padding);
-				});
-				resizeObserver.observe(parent);
-				return () => {
-					resizeObserver.unobserve(parent);
-				};
-			} else setWhiteNoteWidth(_whiteNoteWidth);
-		}, [
-			fill,
-			_whiteNoteWidth,
-			whiteNoteCount
-		]);
-		const { refHandler: touchMoveRefCallback, pointerDownHandler } = usePianoDrag({
-			baseElementRef: pianoRef,
-			onDrag,
-			onDragEnd
-		});
-		useEventListener(globalThis.window, "keydown", (e) => {
-			if (e.repeat) return;
-			if (!keyboardShortcuts) return;
-			const index = keyboardShortcuts.keys.indexOf(e.key);
-			if (index != -1) {
-				if (!keyRefs.current[index]?.current?.played()) keyRefs.current[index]?.current?.play();
-			}
-		});
-		useEventListener(globalThis.window, "keyup", (e) => {
-			if (e.repeat) return;
-			if (!keyboardShortcuts) return;
-			const index = keyboardShortcuts.keys.indexOf(e.key);
-			if (index != -1) keyRefs.current[index]?.current?.stop();
-		});
-		useImperativeHandle(forwardedRef, () => {
-			return {
-				playNote(note, velocity) {
-					const index = noteRangeArray.indexOf(note);
-					if (index != -1) {
-						if (!keyRefs.current[index]?.current?.played()) keyRefs.current[index]?.current?.play(velocity);
-					} else onPlayNote?.(note, velocity);
-				},
-				stopNote(note) {
-					const index = noteRangeArray.indexOf(note);
-					if (index != -1) keyRefs.current[index]?.current?.stop();
-					else onStopNote?.(note);
-				}
+		children: notes.map((note, index) => {
+			const keyType = isWhiteKey(note) ? "white" : "black";
+			const state = {
+				index,
+				keyType,
+				active: activeNotes.includes(note),
+				disabled: note > midiMax
 			};
-		}, [
-			noteRangeArray,
-			onPlayNote,
-			onStopNote
-		]);
-		return /* @__PURE__ */ jsx(PianoProvider, {
-			notePosition,
-			noteRange,
-			glissando,
-			midiMax,
-			fill,
-			onPlayNote,
-			onStopNote,
-			label,
-			children: /* @__PURE__ */ jsx("div", {
-				ref: (div) => {
-					pianoRef.current = div;
-					touchMoveRefCallback(div);
-				},
-				className: clsx("tremolo-piano", className),
+			const { className: keyClassName, style: keyStyle, ...rest } = keyProps?.(note, state) ?? {};
+			const content = label?.(note, state);
+			return /* @__PURE__ */ jsx("div", {
+				className: clsx(`tremolo-piano-${keyType}-key`, keyClassName),
+				"data-note": note,
+				"data-note-key": noteKey(note),
+				"data-active": state.active,
+				"aria-disabled": state.disabled,
+				...rest,
 				style: {
-					width: fill ? "100%" : staticWidth,
-					height,
-					...style
-				},
-				onPointerDown: (event) => {
-					pointerDownHandler(event);
-					onPointerDown?.(event);
+					...keyStyle,
+					left: notePosition(note, layout),
+					width: keyType === "white" ? layout.whiteKeyWidth : blackKeyWidth(layout),
+					height: keyType === "white" ? "100%" : `${blackKeyHeightRatio * 100}%`
 				},
-				...props,
-				children: childrenWithProps || noteRangeArray.map((note, index) => isWhiteKey(note) ? /* @__PURE__ */ jsx(WhiteKey, {
-					ref: keyRefs.current[index],
-					noteNumber: note,
-					__width: whiteNoteWidth
-				}, note) : /* @__PURE__ */ jsx(BlackKey, {
-					ref: keyRefs.current[index],
-					noteNumber: note,
-					__width: whiteNoteWidth * blackPerWhiteWidth
-				}, note))
-			})
-		});
-	}),
-	WhiteKey,
-	BlackKey,
-	KeyLabel
-};
+				children: content !== "" && content !== null && content !== void 0 && /* @__PURE__ */ jsx("div", {
+					className: "tremolo-piano-key-label-wrapper",
+					children: /* @__PURE__ */ jsx("div", {
+						className: "tremolo-piano-key-label",
+						children: content
+					})
+				})
+			}, note);
+		})
+	});
+}) };
 //#endregion
 //#region src/components/PointsEditor/Background.tsx
 function Background({ className, children, ...props }) {
@@ -1331,111 +1126,24 @@ function Background({ className, children, ...props }) {
 }
 //#endregion
 //#region src/components/PointsEditor/context.tsx
-const createPointsEditorStore = (initProps) => {
-	const DEFAULT_PROPS = {
-		containerElementRef: createRef(),
-		disabled: false,
-		readonly: false,
-		externalStyles: {
-			userSelectNone: true,
-			cursor: "grabbing"
-		}
-	};
-	return createStore()((set) => ({
-		...DEFAULT_PROPS,
-		...initProps,
-		setContainerElementRef: (containerElementRef) => {
-			set(() => ({ containerElementRef }));
-		}
-	}));
-};
 const PointsEditorContext = createContext(null);
-function PointsEditorProvider({ children, ...props }) {
-	const storeRef = useRef(null);
-	if (!storeRef.current) storeRef.current = createPointsEditorStore(props);
-	useEffect(() => {
-		if (storeRef.current) storeRef.current.setState(props);
-		else storeRef.current = createPointsEditorStore(props);
-	}, [props]);
-	return /* @__PURE__ */ jsx(PointsEditorContext.Provider, {
-		value: storeRef.current,
-		children
-	});
-}
+const PointsEditorProvider = PointsEditorContext.Provider;
 function usePointsEditorContext(selector) {
-	const store = useContext(PointsEditorContext);
-	if (!store) throw new Error("Missing PointsEditorContext.Provider in the tree");
-	return useStore(store, selector);
+	const context = useContext(PointsEditorContext);
+	if (!context) throw new Error("Missing PointsEditorContext.Provider in the tree");
+	return selector ? selector(context) : context;
 }
 //#endregion
 //#region src/components/PointsEditor/Container.tsx
-function Container({ className, children, ...props }) {
-	const containerElementRef = useRef(null);
-	usePointsEditorContext((s) => s.setContainerElementRef)(containerElementRef);
+function Container({ children, className, ref, ...props }) {
 	return /* @__PURE__ */ jsx("div", {
-		ref: containerElementRef,
+		ref: useComposedRefs(ref, usePointsEditorContext((s) => s.containerRef)),
 		className: clsx("tremolo-points-editor-container", className),
 		...props,
 		children
 	});
 }
 //#endregion
-//#region src/hooks/useDragWithElement.ts
-/**
-* Track a pointer drag, reporting the position normalized against
-* the bounding rect of `baseElementRef`.
-*
-* @returns a ref callback for the element that starts the drag, and whether a drag is in progress
-*/
-function useDragWithElement({ baseElementRef, updateOnPointerDown = false, cursor, onDrag, onDragStart, onDragEnd }) {
-	const [dragging, setDragging] = useState(false);
-	const normalizedX = useRef(0);
-	const normalizedY = useRef(0);
-	const dragHandler = useCallbackRef(onDrag);
-	const dragStartHandler = useCallbackRef(onDragStart);
-	const dragEndHandler = useCallbackRef(onDragEnd);
-	const update = useCallback((clientX, clientY) => {
-		const base = baseElementRef.current;
-		if (!base) return false;
-		const { left, top, right, bottom } = base.getBoundingClientRect();
-		normalizedX.current = normalizeValue(clientX, left, right);
-		normalizedY.current = normalizeValue(clientY, top, bottom);
-		return true;
-	}, [baseElementRef]);
-	const [node, setNode] = useState(null);
-	useEffect(() => {
-		if (!node) return;
-		const instance = createDrag(node, {
-			cursor,
-			onDragStart: ({ clientX, clientY }) => {
-				setDragging(true);
-				if (update(clientX, clientY) && updateOnPointerDown) dragHandler(normalizedX.current, normalizedY.current);
-				dragStartHandler(normalizedX.current, normalizedY.current);
-			},
-			onDrag: ({ clientX, clientY }) => {
-				if (update(clientX, clientY)) dragHandler(normalizedX.current, normalizedY.current);
-			},
-			onDragEnd: () => {
-				setDragging(false);
-				dragEndHandler(normalizedX.current, normalizedY.current);
-			}
-		});
-		return () => instance.destroy();
-	}, [
-		node,
-		update,
-		updateOnPointerDown,
-		cursor,
-		dragHandler,
-		dragStartHandler,
-		dragEndHandler
-	]);
-	return {
-		refCallback: setNode,
-		dragging
-	};
-}
-//#endregion
 //#region src/components/PointsEditor/Point.tsx
 function clampPoint(point, min, max) {
 	const { x, y } = point;
@@ -1444,22 +1152,33 @@ function clampPoint(point, min, max) {
 		y: clamp(y, min?.y ?? 0, max?.y ?? 1)
 	};
 }
-function Point({ value, min, max, size, width = 16, height = 16, color, disabled, readonly, onChange, onDragStart, onDragEnd, className, style, onPointerDown, ...props }) {
-	const containerElementRef = usePointsEditorContext((s) => s.containerElementRef);
-	const externalStyles = usePointsEditorContext((s) => s.externalStyles);
-	const __disabled = usePointsEditorContext((s) => s.disabled);
-	const __readonly = usePointsEditorContext((s) => s.readonly);
-	const { refCallback: dragRefCallback, dragging } = useDragWithElement({
-		baseElementRef: containerElementRef,
+/**
+* A point is placed by its position within the container, so its value is a
+* position: 0..1 on each axis, with y growing downwards.
+*/
+const AXIS = {
+	min: 0,
+	max: 1
+};
+function Point({ value, min, max, size, width = 16, height = 16, color, disabled: _disabled, readonly: _readonly, wheel: _wheel, keyboard: _keyboard, onChange, onDragStart, onDragEnd, className, style, onPointerDown, onKeyDown, ...props }) {
+	const { containerRef, externalStyles, disabled: rootDisabled, readonly: rootReadonly, wheel: rootWheel, keyboard: rootKeyboard } = usePointsEditorContext();
+	const disabled = _disabled ?? rootDisabled;
+	const readonly = _readonly ?? rootReadonly;
+	const wheel = _wheel === void 0 ? rootWheel : _wheel;
+	const keyboard = _keyboard === void 0 ? rootKeyboard : _keyboard;
+	const [element, setElement] = useState(null);
+	const { refCallback: dragRefCallback, dragging } = useDragValue({
+		axis: AXIS,
+		baseElementRef: containerRef,
 		cursor: readonly ? void 0 : externalStyles.cursor,
-		onDrag: (x, y) => {
+		onChange: ([x, y]) => {
 			if (readonly) return;
 			onChange?.(clampPoint({
 				x,
 				y
 			}, min, max));
 		},
-		onDragStart: (x, y) => {
+		onDragStart: ([x, y]) => {
 			if (readonly) return;
 			if (externalStyles.userSelectNone) addUserSelectNone();
 			onDragStart?.(clampPoint({
@@ -1467,7 +1186,7 @@ function Point({ value, min, max, size, width = 16, height = 16, color, disabled
 				y
 			}, min, max));
 		},
-		onDragEnd: (x, y) => {
+		onDragEnd: ([x, y]) => {
 			if (readonly) return;
 			if (externalStyles.userSelectNone) removeUserSelectNone();
 			onDragEnd?.(clampPoint({
@@ -1476,13 +1195,45 @@ function Point({ value, min, max, size, width = 16, height = 16, color, disabled
 			}, min, max));
 		}
 	});
+	const nudge = useCallback((axis, direction, option) => {
+		const next = applyDelta(value[axis], direction, option, AXIS);
+		onChange?.(clampPoint({
+			...value,
+			[axis]: next
+		}, min, max));
+	}, [
+		value,
+		min,
+		max,
+		onChange
+	]);
+	useWheel((event) => {
+		if (!onChange || readonly || !wheel) return;
+		if (!element || element.ownerDocument.activeElement !== element) return;
+		event.preventDefault();
+		nudge(event.shiftKey ? "x" : "y", event.deltaY < 0 ? -1 : 1, wheel);
+	}, { target: containerRef });
+	const refCallback = useComposedRefs(dragRefCallback, setElement);
+	const handleKeyDown = (event) => {
+		if (!onChange || readonly || !keyboard) return;
+		const key = event.key;
+		if ([
+			"ArrowRight",
+			"ArrowLeft",
+			"ArrowUp",
+			"ArrowDown"
+		].includes(key)) {
+			event.preventDefault();
+			nudge(key === "ArrowRight" || key === "ArrowLeft" ? "x" : "y", key === "ArrowLeft" || key === "ArrowUp" ? -1 : 1, keyboard);
+		}
+	};
 	const colors = { "--color": color };
 	return /* @__PURE__ */ jsx("div", {
-		ref: dragRefCallback,
+		ref: refCallback,
 		className: clsx("tremolo-points-editor-point", className),
 		tabIndex: 0,
-		"aria-disabled": disabled != void 0 ? disabled : __disabled,
-		"aria-readonly": readonly != void 0 ? readonly : __readonly,
+		"aria-disabled": disabled,
+		"aria-readonly": readonly,
 		"data-dragging": dragging,
 		style: {
 			...colors,
@@ -1493,30 +1244,51 @@ function Point({ value, min, max, size, width = 16, height = 16, color, disabled
 			...style
 		},
 		onPointerDown,
+		onKeyDown: (event) => {
+			handleKeyDown(event);
+			onKeyDown?.(event);
+		},
 		...props
 	});
 }
 //#endregion
 //#region src/components/PointsEditor/index.tsx
-const defaultExternalStyles$2 = {
-	userSelectNone: true,
-	cursor: "grabbing"
-};
+/**
+* A point moves over 0..1 in both axes, so a nudge of 0.01 crosses the editor
+* in a hundred steps whatever its pixel size.
+*/
+const DEFAULT_INPUT_EVENT_OPTION = ["normalized", .01];
 /**
 * Multiple Point Controller
 */
 const PointsEditor = {
-	Root: forwardRef(({ width = 200, height = 100, disabled = false, readonly = false, externalStyles: _externalStyles, style, className, children, ...props }, forwardedRef) => {
+	Root: forwardRef(({ width = 200, height = 100, disabled = false, readonly = false, wheel = DEFAULT_INPUT_EVENT_OPTION, keyboard = DEFAULT_INPUT_EVENT_OPTION, externalStyles, style, className, children, ...props }, forwardedRef) => {
+		const containerRef = useRef(null);
+		const { userSelectNone = true, cursor = "grabbing" } = externalStyles ?? {};
 		return /* @__PURE__ */ jsx(PointsEditorProvider, {
-			disabled,
-			readonly,
-			externalStyles: {
-				...defaultExternalStyles$2,
-				..._externalStyles
-			},
+			value: useMemo(() => ({
+				disabled,
+				readonly,
+				wheel,
+				keyboard,
+				externalStyles: {
+					userSelectNone,
+					cursor
+				},
+				containerRef
+			}), [
+				disabled,
+				readonly,
+				wheel,
+				keyboard,
+				userSelectNone,
+				cursor
+			]),
 			children: /* @__PURE__ */ jsx("div", {
 				ref: forwardedRef,
 				className: clsx("tremolo-points-editor", className),
+				"aria-disabled": disabled,
+				"aria-readonly": readonly,
 				style: {
 					width,
 					height,
@@ -1533,59 +1305,33 @@ const PointsEditor = {
 };
 //#endregion
 //#region src/components/Slider/context.tsx
-const createSliderStore = (initProps) => {
-	const DEFAULT_PROPS = {
-		min: 0,
-		max: 0,
-		step: 0,
-		skew: 0,
-		vertical: false,
-		reverse: false,
-		disabled: false,
-		readonly: false
-	};
-	return createStore()(() => ({
-		...DEFAULT_PROPS,
-		...initProps
-	}));
-};
 const SliderContext = createContext(null);
-function SliderProvider({ children, ...props }) {
-	const storeRef = useRef(null);
-	if (!storeRef.current) storeRef.current = createSliderStore(props);
-	useEffect(() => {
-		if (storeRef.current) storeRef.current.setState(props);
-		else storeRef.current = createSliderStore(props);
-	}, [props]);
-	return /* @__PURE__ */ jsx(SliderContext.Provider, {
-		value: storeRef.current,
-		children
-	});
-}
+const SliderProvider = SliderContext.Provider;
 function useSliderContext(selector) {
-	const store = useContext(SliderContext);
-	if (!store) throw new Error("Missing SliderContext.Provider in the tree");
-	return useStore(store, selector);
+	const context = useContext(SliderContext);
+	if (!context) throw new Error("Missing SliderContext.Provider in the tree");
+	return selector ? selector(context) : context;
 }
 //#endregion
-//#region src/components/Slider/ScaleOption.tsx
-function ScaleOption({ value, type = "mark-number", label, thickness = 1, length = "0.5rem", gap = 2, labelWidth, classes, styles, className, style, ...props }) {
+//#region src/components/Slider/MarksOption.tsx
+function MarksOption({ value, type = "mark-number", label, thickness = 1, length = "0.5rem", gap = 2, labelWidth, classes, styles, className, style, ...props }) {
 	const min = useSliderContext((s) => s.min);
 	const max = useSliderContext((s) => s.max);
-	const skew = useSliderContext((s) => s.skew);
+	const scale = useSliderContext((s) => s.scale);
 	const vertical = useSliderContext((s) => s.vertical);
 	const reverse = useSliderContext((s) => s.reverse);
-	const calcPercent = useCallback((rawValue) => {
-		return toFixed(xor(vertical, reverse) ? 100 - normalizeValue(rawValue, min, max, skew) * 100 : normalizeValue(rawValue, min, max, skew) * 100);
+	const calcPercent = useCallback((value) => {
+		const percent = scale.normalize(value, min, max) * 100;
+		return toFixed(xor(vertical, reverse) ? 100 - percent : percent);
 	}, [
 		vertical,
 		reverse,
 		max,
 		min,
-		skew
+		scale
 	]);
 	return /* @__PURE__ */ jsxs("div", {
-		className: clsx("tremolo-slider-scale-option", className),
+		className: clsx("tremolo-slider-marks-option", className),
 		style: {
 			left: !vertical ? `${calcPercent(value)}%` : void 0,
 			top: vertical ? `${calcPercent(value)}%` : void 0,
@@ -1594,7 +1340,7 @@ function ScaleOption({ value, type = "mark-number", label, thickness = 1, length
 		"data-vertical": vertical,
 		...props,
 		children: [type != "number" && /* @__PURE__ */ jsx("div", {
-			className: clsx("tremolo-slider-scale-option-mark", classes?.mark),
+			className: clsx("tremolo-slider-marks-option-mark", classes?.mark),
 			style: {
 				width: !vertical ? thickness : length,
 				height: vertical ? thickness : length,
@@ -1604,7 +1350,7 @@ function ScaleOption({ value, type = "mark-number", label, thickness = 1, length
 			},
 			"data-vertical": vertical
 		}), type != "mark" && /* @__PURE__ */ jsx("div", {
-			className: clsx("tremolo-slider-scale-option-label", classes?.label),
+			className: clsx("tremolo-slider-marks-option-label", classes?.label),
 			style: {
 				width: labelWidth,
 				...styles?.label
@@ -1629,8 +1375,8 @@ function generateOptionsList(options, min, max, step) {
 	return optionsList;
 }
 //#endregion
-//#region src/components/Slider/Scale.tsx
-function Scale({ gap = 6, options, children, className, style, ...props }) {
+//#region src/components/Slider/Marks.tsx
+function Marks({ gap = 6, options, children, className, style, ...props }) {
 	const min = useSliderContext((s) => s.min);
 	const max = useSliderContext((s) => s.max);
 	const step = useSliderContext((s) => s.step);
@@ -1639,7 +1385,7 @@ function Scale({ gap = 6, options, children, className, style, ...props }) {
 	const optionsList = options ? generateOptionsList(options, min, max, step) : [];
 	if (xor(vertical, reverse)) optionsList.reverse();
 	return /* @__PURE__ */ jsx("div", {
-		className: clsx("tremolo-slider-scale", className),
+		className: clsx("tremolo-slider-marks", className),
 		style: {
 			marginLeft: vertical ? gap : void 0,
 			marginTop: !vertical ? gap : void 0,
@@ -1647,72 +1393,70 @@ function Scale({ gap = 6, options, children, className, style, ...props }) {
 		},
 		...props,
 		children: options ? optionsList.map(({ value, type }, index) => {
-			return /* @__PURE__ */ jsx(ScaleOption, {
+			return /* @__PURE__ */ jsx(MarksOption, {
 				value,
 				type
 			}, index);
 		}) : children
 	});
 }
-const Thumb$1 = forwardRef(({ size, width = 22, height = 22, color, children, className, style, __percent }, ref) => {
-	const wrapperRef = useRef(null);
-	const vertical = useSliderContext((s) => s.vertical);
-	const disabled = useSliderContext((s) => s.disabled);
-	const readonly = useSliderContext((s) => s.readonly);
-	useImperativeHandle(ref, () => {
-		return {
-			focus() {
-				wrapperRef.current?.focus();
-			},
-			blur() {
-				wrapperRef.current?.blur();
-			}
-		};
-	}, []);
+//#endregion
+//#region src/components/Slider/Thumb.tsx
+function Thumb$1({ color, children, className, style, ref }) {
+	const elementRef = useRef(null);
+	const { vertical, disabled, readonly, percent, thumbRef } = useSliderContext();
+	const methods = () => ({
+		focus() {
+			elementRef.current?.focus();
+		},
+		blur() {
+			elementRef.current?.blur();
+		}
+	});
+	useImperativeHandle(ref, methods, []);
+	useImperativeHandle(thumbRef, methods, []);
 	return /* @__PURE__ */ jsx("div", {
 		className: "tremolo-slider-thumb-wrapper",
 		style: {
-			top: vertical ? `${__percent}%` : "50%",
-			left: !vertical ? `${__percent}%` : "50%"
+			top: vertical ? `${percent}%` : "50%",
+			left: !vertical ? `${percent}%` : "50%"
 		},
 		children: children ? children : /* @__PURE__ */ jsx("div", {
-			ref: wrapperRef,
+			ref: elementRef,
 			className: clsx("tremolo-slider-thumb", className),
 			tabIndex: 0,
 			"aria-disabled": disabled,
 			"aria-readonly": readonly,
 			style: {
 				"--color": color,
-				width: size ?? width,
-				height: size ?? height,
 				...style
 			}
 		})
 	});
-});
-function Track({ length = 140, thickness = 10, active, inactive, children, className, style, defaultStyle = true, __thumb, __percent = 0, ...props }) {
-	const vertical = useSliderContext((s) => s.vertical);
-	const reverse = useSliderContext((s) => s.reverse);
-	const disabled = useSliderContext((s) => s.disabled);
+}
+function Track({ length = 140, thickness = 10, active, inactive, children, className, style, defaultStyle = true, ref, ...props }) {
+	const { vertical, reverse, disabled, percent, trackRef } = useSliderContext();
+	const composedRef = useComposedRefs(ref, trackRef);
 	const direction = vertical ? "bottom" : "right";
 	const colors = {
 		"--active": active,
 		"--inactive": inactive
 	};
-	return /* @__PURE__ */ jsxs("div", {
+	return /* @__PURE__ */ jsx("div", {
+		ref: composedRef,
 		className: clsx("tremolo-slider-track", className),
 		"aria-disabled": disabled,
 		"data-vertical": vertical,
 		style: !defaultStyle ? style : {
 			...colors,
-			background: xor(vertical, reverse) ? `linear-gradient(to ${direction}, var(--inactive) ${__percent}%, var(--active) ${__percent}%)` : `linear-gradient(to ${direction}, var(--active) ${__percent}%, var(--inactive) ${__percent}%)`,
+			background: xor(vertical, reverse) ? `linear-gradient(to ${direction}, var(--inactive) ${percent}%, var(--active) ${percent}%)` : `linear-gradient(to ${direction}, var(--active) ${percent}%, var(--inactive) ${percent}%)`,
 			borderRadius: styleHelper(thickness, "/", 2),
 			width: !vertical ? length : thickness,
 			height: vertical ? length : thickness,
 			...style
 		},
 		...props,
-		children: [children, __thumb]
+		children
 	});
 }
 //#endregion
@@ -1722,55 +1466,37 @@ const defaultExternalStyles$1 = {
 	cursor: "pointer"
 };
 /**
+* The wheel only acts while the focus is inside, so that scrolling a page past
+* the control does not change its value.
+*/
+const WHEEL_OPTIONS$1 = { requireFocus: true };
+/**
 * Customizable slider
 */
 const Slider = {
-	Root: forwardRef(({ value, min, max, step = 1, skew = 1, vertical = false, reverse = false, externalStyles: _externalStyles, wheel = ["raw", 1], keyboard = ["raw", 1], disabled = false, readonly = false, onChange, onDragStart, onDragEnd, className, style, children, onFocus, onBlur, onPointerDown, onKeyDown, ...props }, forwardedRef) => {
-		const trackElementRef = useRef(null);
+	Root: forwardRef(({ value, min, max, step = 1, scale = linearScale, vertical = false, reverse = false, externalStyles: _externalStyles, wheel = ["raw", 1], keyboard = ["raw", 1], disabled = false, readonly = false, onChange, onDragStart, onDragEnd, className, style, children, onFocus, onBlur, onPointerDown, onKeyDown, ...props }, forwardedRef) => {
+		const trackRef = useRef(null);
 		const thumbRef = useRef(null);
 		const externalStyles = {
 			...defaultExternalStyles$1,
 			..._externalStyles
 		};
-		const p = toFixed(normalizeValue(value, min, max, skew) * 100);
+		const p = toFixed(scale.normalize(value, min, max) * 100);
 		const rev = toFixed(100 - p);
 		const displayReversed = useMemo(() => xor(vertical, reverse), [vertical, reverse]);
 		const percent = displayReversed ? rev : p;
-		let trackProps = {};
-		let thumbProps = {};
-		let scaleComponent = void 0;
-		if (children != void 0) React.Children.forEach(children, (child) => {
-			if (React.isValidElement(child)) if (child.type == Thumb$1) thumbProps = child.props;
-			else if (child.type == Track) trackProps = child.props;
-			else if (child.type == Scale) scaleComponent = child;
-			else throw new Error("only <SliderThumb> or <SliderTrack>");
-			else throw new Error("children is an invalid element.");
-		});
-		const onDrag = useCallback((nx, ny) => {
-			if (!onChange || readonly) return;
-			const n = vertical ? ny : nx;
-			onChange(clamp(stepValue(rawValue(displayReversed ? 1 - n : n, min, max, skew), step), min, max));
-		}, [
-			displayReversed,
-			max,
+		const axis = useMemo(() => ({
 			min,
-			onChange,
-			readonly,
-			skew,
-			step,
-			vertical
-		]);
-		const updateValueByEvent = useCallback((eventType, x) => {
-			let newValue;
-			if (eventType == "normalized") newValue = rawValue(normalizeValue(value, min, max, skew) + x, min, max, skew);
-			else newValue = value + x;
-			return clamp(stepValue(newValue, step), min, max);
-		}, [
 			max,
+			step,
+			scale,
+			reverse: displayReversed
+		}), [
 			min,
-			skew,
+			max,
 			step,
-			value
+			scale,
+			displayReversed
 		]);
 		const handleKeyDown = useCallback((event) => {
 			if (!keyboard || !onChange || readonly) return;
@@ -1782,46 +1508,77 @@ const Slider = {
 				"ArrowDown"
 			].includes(key)) {
 				event.preventDefault();
-				let x = key == "ArrowRight" || key == "ArrowUp" ? keyboard[1] : -keyboard[1];
-				if (reverse) x *= -1;
-				onChange(updateValueByEvent(keyboard[0], x));
+				let direction = key == "ArrowRight" || key == "ArrowUp" ? 1 : -1;
+				if (reverse) direction *= -1;
+				onChange(applyDelta(value, direction, keyboard, axis));
 			}
 		}, [
 			keyboard,
 			onChange,
 			readonly,
 			reverse,
-			updateValueByEvent
+			value,
+			axis
 		]);
-		const { refCallback: dragRefCallback } = useDragWithElement({
-			baseElementRef: trackElementRef,
+		const valueOf = (v) => v[vertical ? 1 : 0];
+		const { refCallback: dragRefCallback } = useDragValue({
+			axis,
+			baseElementRef: trackRef,
 			cursor: readonly ? void 0 : externalStyles.cursor,
 			updateOnPointerDown: true,
-			onDrag,
-			onDragStart: (nx, ny) => {
+			onChange: (v) => {
+				if (readonly) return;
+				onChange?.(valueOf(v));
+			},
+			onDragStart: (v) => {
 				if (readonly) return;
 				if (externalStyles.userSelectNone) addUserSelectNone();
 				thumbRef.current?.focus();
-				onDragStart?.(clamp(stepValue(rawValue(vertical ? ny : nx, min, max, skew), step), min, max));
+				onDragStart?.(valueOf(v));
 			},
-			onDragEnd: (nx, ny) => {
+			onDragEnd: (v) => {
 				if (readonly) return;
 				if (externalStyles.userSelectNone) removeUserSelectNone();
-				onDragEnd?.(clamp(stepValue(rawValue(vertical ? ny : nx, min, max, skew), step), min, max));
+				onDragEnd?.(valueOf(v));
 			}
 		});
-		const wheelRefCallback = useWheel((event) => {
+		const rootRefCallback = useComposedRefs(dragRefCallback, useWheel((event) => {
 			if (!wheel || !onChange || readonly) return;
 			event.preventDefault();
-			let x;
-			if (!vertical && event.deltaX != 0) x = event.deltaX > 0 ? wheel[1] : -wheel[1];
+			let direction;
+			if (!vertical && event.deltaX != 0) direction = event.deltaX > 0 ? 1 : -1;
 			else {
 				if (event.deltaY == 0) return;
-				x = event.deltaY > 0 ? -wheel[1] : wheel[1];
+				direction = event.deltaY > 0 ? -1 : 1;
 			}
-			if (vertical && reverse) x *= -1;
-			onChange(updateValueByEvent(wheel[0], x));
-		});
+			if (vertical && reverse) direction *= -1;
+			onChange(applyDelta(value, direction, wheel, axis));
+		}, WHEEL_OPTIONS$1));
+		const context = useMemo(() => ({
+			value,
+			min,
+			max,
+			step,
+			scale,
+			vertical,
+			reverse,
+			disabled,
+			readonly,
+			percent,
+			trackRef,
+			thumbRef
+		}), [
+			value,
+			min,
+			max,
+			step,
+			scale,
+			vertical,
+			reverse,
+			disabled,
+			readonly,
+			percent
+		]);
 		useImperativeHandle(forwardedRef, () => {
 			return {
 				focus() {
@@ -1833,20 +1590,10 @@ const Slider = {
 			};
 		}, []);
 		return /* @__PURE__ */ jsx(SliderProvider, {
-			min,
-			max,
-			step,
-			skew,
-			vertical,
-			reverse,
-			disabled,
-			readonly,
+			value: context,
 			children: /* @__PURE__ */ jsx("div", {
 				className: clsx("tremolo-slider", className),
-				ref: (div) => {
-					wheelRefCallback(div);
-					dragRefCallback(div);
-				},
+				ref: rootRefCallback,
 				tabIndex: -1,
 				role: "slider",
 				"aria-valuenow": value,
@@ -1855,10 +1602,8 @@ const Slider = {
 				"aria-orientation": vertical ? "vertical" : "horizontal",
 				"aria-disabled": disabled,
 				"aria-readonly": readonly,
-				style: {
-					margin: `calc(${styleHelper(thumbProps?.size ?? 22)} / 2)`,
-					...style
-				},
+				"data-vertical": vertical,
+				style,
 				onPointerDown,
 				onKeyDown: (event) => {
 					handleKeyDown(event);
@@ -1873,70 +1618,30 @@ const Slider = {
 					onBlur?.(event);
 				},
 				...props,
-				children: /* @__PURE__ */ jsxs("div", {
-					style: {
-						display: "flex",
-						flexDirection: vertical ? "row" : "column",
-						width: !vertical ? "100%" : void 0,
-						height: vertical ? "100%" : void 0
-					},
-					children: [/* @__PURE__ */ jsx("div", {
-						className: "tremolo-slider-track-wrapper",
-						ref: trackElementRef,
-						children: /* @__PURE__ */ jsx(Track, {
-							__percent: percent,
-							__thumb: /* @__PURE__ */ jsx(Thumb$1, {
-								ref: thumbRef,
-								__percent: percent,
-								...thumbProps
-							}),
-							...trackProps
-						})
-					}), scaleComponent]
-				})
+				children
 			})
 		});
 	}),
 	Thumb: Thumb$1,
 	Track,
-	Scale,
-	ScaleOption
+	Marks,
+	MarksOption
 };
 //#endregion
-//#region src/components/_util/composeRefs.tsx
-/**
-* Set a given ref to a given value
-* This utility takes care of different types of refs: callback refs and RefObject(s)
-*/
-function setRef(ref, value) {
-	if (typeof ref === "function") return ref(value);
-	else if (ref !== null && ref !== void 0) ref.current = value;
-}
-/**
-* A utility to compose multiple refs together
-* Accepts callback refs and RefObject(s)
-*/
-function composeRefs(...refs) {
-	return (node) => {
-		let hasCleanup = false;
-		const cleanups = refs.map((ref) => {
-			const cleanup = setRef(ref, node);
-			if (!hasCleanup && typeof cleanup == "function") hasCleanup = true;
-			return cleanup;
-		});
-		if (hasCleanup) return () => {
-			for (let i = 0; i < cleanups.length; i++) {
-				const cleanup = cleanups[i];
-				if (typeof cleanup == "function") cleanup();
-				else setRef(refs[i], null);
-			}
-		};
-	};
+//#region src/components/XYPad/context.tsx
+const XYPadContext = createContext(null);
+const XYPadProvider = XYPadContext.Provider;
+function useXYPadContext(selector) {
+	const context = useContext(XYPadContext);
+	if (!context) throw new Error("Missing XYPadContext.Provider in the tree");
+	return selector ? selector(context) : context;
 }
 //#endregion
 //#region src/components/XYPad/Area.tsx
-function Area({ width = 120, height = 120, color, children, className, style, __thumb, ...props }) {
-	return /* @__PURE__ */ jsxs("div", {
+function Area({ width = 120, height = 120, color, children, className, style, ref, ...props }) {
+	const { areaRef } = useXYPadContext();
+	return /* @__PURE__ */ jsx("div", {
+		ref: useComposedRefs(ref, areaRef),
 		className: clsx("tremolo-xy-pad-area", className),
 		style: {
 			"--color": color,
@@ -1945,121 +1650,105 @@ function Area({ width = 120, height = 120, color, children, className, style, __
 			...style
 		},
 		...props,
-		children: [children, __thumb]
+		children
 	});
 }
 //#endregion
 //#region src/components/XYPad/Thumb.tsx
-const Thumb = forwardRef(({ size, width = 22, height = 22, color, children, wrapperClassName, wrapperStyle, className, style, __disabled, __readonly, __css, ...props }, ref) => {
-	const wrapperRef = useRef(null);
-	useImperativeHandle(ref, () => {
-		return {
-			focus() {
-				wrapperRef.current?.focus();
-			},
-			blur() {
-				wrapperRef.current?.blur();
-			}
-		};
-	}, []);
+function Thumb({ color, children, wrapperClassName, wrapperStyle, className, style, ref, ...props }) {
+	const elementRef = useRef(null);
+	const { disabled, readonly, percent, thumbRef } = useXYPadContext();
+	const methods = () => ({
+		focus() {
+			elementRef.current?.focus();
+		},
+		blur() {
+			elementRef.current?.blur();
+		}
+	});
+	useImperativeHandle(ref, methods, []);
+	useImperativeHandle(thumbRef, methods, []);
 	return /* @__PURE__ */ jsx("div", {
 		className: clsx("tremolo-xy-pad-thumb-wrapper", wrapperClassName),
 		style: {
-			...__css,
+			left: `${percent[0]}%`,
+			top: `${percent[1]}%`,
 			...wrapperStyle
 		},
 		...props,
 		children: children ? children : /* @__PURE__ */ jsx("div", {
-			ref: wrapperRef,
+			ref: elementRef,
 			className: clsx("tremolo-xy-pad-thumb", className),
 			tabIndex: 0,
-			"aria-disabled": __disabled,
-			"aria-readonly": __readonly,
+			"aria-disabled": disabled,
+			"aria-readonly": readonly,
 			style: {
 				"--color": color,
-				width: size ?? width,
-				height: size ?? height,
 				...style
 			}
 		})
 	});
-});
+}
 //#endregion
 //#region src/components/XYPad/index.tsx
-const defaultValueOptions = {
-	skew: 1,
-	step: 1,
-	reverse: false,
-	wheel: ["raw", 1],
-	keyboard: ["raw", 1]
-};
 const defaultExternalStyles = {
 	userSelectNone: true,
 	cursor: "pointer"
 };
 /**
+* The wheel only acts while the focus is inside, so that scrolling a page past
+* the control does not change its value.
+*/
+const WHEEL_OPTIONS = { requireFocus: true };
+/**
 * Simple XYPad
 */
 const XYPad = {
-	Root: forwardRef(({ x: _x, y: _y, className, style, externalStyles: _externalStyles, disabled = false, readonly = false, onChange, onDragStart, onDragEnd, onPointerDown, onKeyDown, onFocus, onBlur, children, ...props }, forwardedRef) => {
-		const x = useMemo(() => {
-			return {
-				...defaultValueOptions,
-				..._x
-			};
-		}, [_x]);
-		const y = useMemo(() => {
-			return {
-				...defaultValueOptions,
-				..._y
-			};
-		}, [_y]);
+	Root: forwardRef(({ value, min: _min, max: _max, step: _step = 1, scale: _scale = linearScale, reverse: _reverse = false, wheel = ["raw", 1], keyboard = ["raw", 1], className, style, externalStyles: _externalStyles, disabled = false, readonly = false, onChange, onDragStart, onDragEnd, onPointerDown, onKeyDown, onFocus, onBlur, children, ...props }, forwardedRef) => {
 		const rootRef = useRef(null);
-		const areaElementRef = useRef(null);
+		const areaRef = useRef(null);
 		const thumbRef = useRef(null);
 		const externalStyles = {
 			...defaultExternalStyles,
 			..._externalStyles
 		};
-		const nx = normalizeValue(x.value, x.min, x.max, x.skew);
-		const ny = normalizeValue(y.value, y.min, y.max, y.skew);
-		const percentX = toFixed((x.reverse ? 1 - nx : nx) * 100);
-		const percentY = toFixed((y.reverse ? 1 - ny : ny) * 100);
-		let areaProps = {};
-		let thumbProps = {};
-		if (children != void 0) React.Children.forEach(children, (child) => {
-			if (React.isValidElement(child)) if (child.type == Thumb) thumbProps = child.props;
-			else if (child.type == Area) areaProps = child.props;
-			else throw new Error("only <XYPadThumb> or <XYPadArea>");
-			else throw new Error("children is an invalid element.");
-		});
-		const onDrag = useCallback((nx, ny) => {
-			if (!onChange || readonly) return;
-			const vx = rawValue(x.reverse ? 1 - nx : nx, x.min, x.max, x.skew);
-			const vy = rawValue(y.reverse ? 1 - ny : ny, y.min, y.max, y.skew);
-			onChange(clamp(stepValue(vx, x.step), x.min, x.max), clamp(stepValue(vy, y.step), y.min, y.max));
+		const min = useMemo(() => toXY(_min), [_min]);
+		const max = useMemo(() => toXY(_max), [_max]);
+		const step = useMemo(() => toXY(_step), [_step]);
+		const scale = useMemo(() => toXY(_scale), [_scale]);
+		const reverse = useMemo(() => toXY(_reverse), [_reverse]);
+		const percent = useMemo(() => {
+			const normalized = [0, 1].map((i) => scale[i].normalize(value[i], min[i], max[i]));
+			return [0, 1].map((i) => toFixed((reverse[i] ? 1 - normalized[i] : normalized[i]) * 100));
 		}, [
-			onChange,
-			readonly,
-			x.max,
-			x.min,
-			x.reverse,
-			x.skew,
-			x.step,
-			y.max,
-			y.min,
-			y.reverse,
-			y.skew,
-			y.step
+			value,
+			min,
+			max,
+			scale,
+			reverse
+		]);
+		const axis = useMemo(() => [0, 1].map((i) => ({
+			min: min[i],
+			max: max[i],
+			step: step[i],
+			scale: scale[i],
+			reverse: reverse[i]
+		})), [
+			min,
+			max,
+			step,
+			scale,
+			reverse
+		]);
+		const withAxis = useCallback((axis, next) => axis == 0 ? [next, value[1]] : [value[0], next], [value]);
+		/** @param i 0 = x, 1 = y */
+		const nudge = useCallback((i, direction, option) => withAxis(i, applyDelta(value[i], direction, option, axis[i])), [
+			value,
+			axis,
+			withAxis
 		]);
-		const updateValueByEvent = useCallback((eventType, target, x) => {
-			let v;
-			if (eventType == "normalized") v = rawValue(normalizeValue(target.value, target.min, target.max, target.skew) + x, target.min, target.max, target.skew);
-			else v = target.value + x;
-			return clamp(stepValue(v, target.step), target.min, target.max);
-		}, []);
 		const handleKeyDown = useCallback((event) => {
-			if (!onChange || readonly) return;
+			if (!onChange || readonly || !keyboard) return;
 			const key = event.key;
 			if ([
 				"ArrowRight",
@@ -2067,57 +1756,73 @@ const XYPad = {
 				"ArrowUp",
 				"ArrowDown"
 			].includes(key)) {
-				const isHorizontal = key == "ArrowRight" || key == "ArrowLeft";
-				const target = isHorizontal ? x : y;
-				if (!target.keyboard) return;
+				const i = key == "ArrowRight" || key == "ArrowLeft" ? 0 : 1;
 				event.preventDefault();
-				let delta = target.keyboard[1];
-				if (key == "ArrowLeft" || key == "ArrowUp") delta *= -1;
-				if (target.reverse) delta *= -1;
-				const newValue = updateValueByEvent(target.keyboard[0], target, delta);
-				if (isHorizontal) onChange(newValue, y.value);
-				else onChange(x.value, newValue);
+				let direction = 1;
+				if (key == "ArrowLeft" || key == "ArrowUp") direction *= -1;
+				if (reverse[i]) direction *= -1;
+				onChange(nudge(i, direction, keyboard));
 			}
 		}, [
 			onChange,
 			readonly,
-			x,
-			y,
-			updateValueByEvent
+			keyboard,
+			reverse,
+			nudge
 		]);
-		const { refCallback: dragRefCallback } = useDragWithElement({
-			baseElementRef: areaElementRef,
-			cursor: readonly ? void 0 : externalStyles.cursor,
+		const { refCallback: dragRefCallback } = useDragValue({
+			axis,
+			baseElementRef: areaRef,
 			updateOnPointerDown: true,
-			onDrag,
-			onDragStart: (nx, ny) => {
+			cursor: readonly ? void 0 : externalStyles.cursor,
+			onChange: (v) => {
+				if (readonly) return;
+				onChange?.(v);
+			},
+			onDragStart: (v) => {
 				if (readonly) return;
 				if (externalStyles.userSelectNone) addUserSelectNone();
 				thumbRef.current?.focus();
-				const valueX = clamp(stepValue(rawValue(nx, x.min, x.max, x.skew), x.step), x.min, x.max);
-				const valueY = clamp(stepValue(rawValue(ny, y.min, y.max, y.skew), y.step), y.min, y.max);
-				onDragStart?.(valueX, valueY);
+				onDragStart?.(v);
 			},
-			onDragEnd: (nx, ny) => {
+			onDragEnd: (v) => {
 				if (readonly) return;
 				if (externalStyles.userSelectNone) removeUserSelectNone();
-				const valueX = clamp(stepValue(rawValue(nx, x.min, x.max, x.skew), x.step), x.min, x.max);
-				const valueY = clamp(stepValue(rawValue(ny, y.min, y.max, y.skew), y.step), y.min, y.max);
-				onDragEnd?.(valueX, valueY);
+				onDragEnd?.(v);
 			}
 		});
-		const wheelRefCallback = useWheel((event) => {
-			if (!onChange || readonly) return;
-			const target = event.shiftKey ? x : y;
-			if (!target.wheel) return;
+		const rootRefCallback = useComposedRefs(rootRef, dragRefCallback, useWheel((event) => {
+			if (!onChange || readonly || !wheel) return;
+			const i = event.shiftKey ? 0 : 1;
 			event.preventDefault();
-			let delta = target.wheel[1];
-			if (event.deltaY < 0) delta *= -1;
-			if (target.reverse) delta *= -1;
-			const newValue = updateValueByEvent(target.wheel[0], target, delta);
-			if (event.shiftKey) onChange(newValue, y.value);
-			else onChange(x.value, newValue);
-		});
+			let direction = 1;
+			if (event.deltaY < 0) direction *= -1;
+			if (reverse[i]) direction *= -1;
+			onChange(nudge(i, direction, wheel));
+		}, WHEEL_OPTIONS));
+		const context = useMemo(() => ({
+			value,
+			min,
+			max,
+			step,
+			scale,
+			reverse,
+			disabled,
+			readonly,
+			percent,
+			areaRef,
+			thumbRef
+		}), [
+			value,
+			min,
+			max,
+			step,
+			scale,
+			reverse,
+			disabled,
+			readonly,
+			percent
+		]);
 		useImperativeHandle(forwardedRef, () => {
 			return {
 				focus() {
@@ -2129,48 +1834,30 @@ const XYPad = {
 				original: rootRef
 			};
 		}, []);
-		return /* @__PURE__ */ jsx("div", {
-			className: clsx("tremolo-xy-pad", className),
-			ref: composeRefs(rootRef, wheelRefCallback, dragRefCallback),
-			tabIndex: -1,
-			"aria-disabled": disabled,
-			"aria-readonly": readonly,
-			style: {
-				margin: `calc(${styleHelper(thumbProps?.size ?? 22)} / 2)`,
-				cursor: readonly ? "not-allowed" : "pointer",
-				WebkitTapHighlightColor: "transparent",
-				...style
-			},
-			onPointerDown,
-			onKeyDown: (event) => {
-				handleKeyDown(event);
-				onKeyDown?.(event);
-			},
-			onFocus: (event) => {
-				thumbRef.current?.focus();
-				onFocus?.(event);
-			},
-			onBlur: (event) => {
-				thumbRef.current?.blur();
-				onBlur?.(event);
-			},
-			...props,
+		return /* @__PURE__ */ jsx(XYPadProvider, {
+			value: context,
 			children: /* @__PURE__ */ jsx("div", {
-				className: "tremolo-xy-pad-area-wrapper",
-				ref: areaElementRef,
-				children: /* @__PURE__ */ jsx(Area, {
-					__thumb: /* @__PURE__ */ jsx(Thumb, {
-						ref: thumbRef,
-						__disabled: disabled,
-						__readonly: readonly,
-						__css: {
-							top: `${percentY}%`,
-							left: `${percentX}%`
-						},
-						...thumbProps
-					}),
-					...areaProps
-				})
+				className: clsx("tremolo-xy-pad", className),
+				ref: rootRefCallback,
+				tabIndex: -1,
+				"aria-disabled": disabled,
+				"aria-readonly": readonly,
+				style,
+				onPointerDown,
+				onKeyDown: (event) => {
+					handleKeyDown(event);
+					onKeyDown?.(event);
+				},
+				onFocus: (event) => {
+					thumbRef.current?.focus();
+					onFocus?.(event);
+				},
+				onBlur: (event) => {
+					thumbRef.current?.blur();
+					onBlur?.(event);
+				},
+				...props,
+				children
 			})
 		});
 	}),
@@ -2242,6 +1929,6 @@ function useMIDIMessage(midiAccess, onMIDIMessage) {
 	}, [midiAccess, onMIDIMessage]);
 }
 //#endregion
-export { AnimationCanvas, Knob, NOT_SUPPORTED, NumberInput, PERMISSION_DENIED, Piano, PointsEditor, SHORTCUTS, Slider, XYPad, clampPoint, getNoteRangeArray, useAnimationFrame, useDrag, useDragWithElement, useEventListener, useInterval, useLongPress, useMIDIAccess, useMIDIInput, useMIDIMessage, useSliderContext, useWheel };
+export { AnimationCanvas, Knob, NOT_SUPPORTED, NumberInput, PERMISSION_DENIED, Piano, PointsEditor, SHORTCUTS, Slider, XYPad, clampPoint, useAnimationFrame, useDrag, useDragValue, useEventListener, useInterval, useLongPress, useMIDIAccess, useMIDIInput, useMIDIMessage, useNumberInputContext, usePointsEditorContext, useSliderContext, useWheel };
 
 //# sourceMappingURL=index.js.map