@tremolo-ui/functions 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -25,17 +25,55 @@ function rawValue(normalizedValue, min, max) {
 	if (min >= max) throw new RangeError("requirements: min < max");
 	return min + clamp(normalizedValue, 0, 1) * (max - min);
 }
+/**
+* Put a value on the grid the caller asked for, rounding a half step upwards.
+*
+* The rounding is done on the quotient rather than by comparing the distance
+* to the two neighbours, because both of those carry error of their own. The
+* quotient is cleared of its artefact first: `0.15 / 0.1` is 1.4999999999999998,
+* and a value sitting exactly on a half step would otherwise fall to whichever
+* side the last bit happened to land on — 0.25 rounded up while 0.15 and 0.35
+* rounded down.
+*/
 function stepValue(value, step) {
 	if (step <= 0) throw new RangeError("requirements: step > 0");
-	const quotient = Math.floor(value / step);
-	const decimalDigits = decimalPart(step)?.length;
-	const v = toFixed(quotient * step, decimalDigits);
-	const next = toFixed((quotient + 1) * step, decimalDigits);
-	return Math.abs(value - v) < Math.abs(value - next) ? v : next;
+	const stepped = toPrecision(Math.round(toPrecision(value / step)) * step);
+	return stepped === 0 ? 0 : stepped;
 }
 function toFixed(x, fractionDigits) {
 	return Number(x.toFixed(fractionDigits));
 }
+/**
+* The significant decimal digits a double actually carries. A double holds a
+* little under 16, so anything past this is the binary representation showing
+* through rather than information.
+*/
+const SIGNIFICANT_DIGITS = 15;
+/**
+* Drop the binary artefact from a computed value.
+*
+* Arithmetic on doubles leaves debris in the last couple of digits, and it
+* accumulates: adding 0.1 to 5 twelve times gives 5.699999999999998 rather
+* than 5.7, and the display of a control shows exactly that. Rounding to the
+* digits a double can carry removes it, and adds nothing back — the value was
+* already the result of a calculation whose own error is that size or larger.
+*
+* This is not the same as rounding to a `step`. {@link stepValue} puts a value
+* on a grid the caller asked for and is a decision about the value; this only
+* removes what was never in the value to begin with.
+*
+* @param significantDigits how many digits to keep. The default is the only
+* one that is purely artefact removal; a smaller number starts discarding real
+* precision.
+*
+* @example
+* toPrecision(5.1 + 0.1) // 5.2, rather than 5.199999999999999
+*/
+function toPrecision(x, significantDigits = 15) {
+	if (x === 0 || !Number.isFinite(x)) return x;
+	const rounded = Number(x.toPrecision(significantDigits));
+	return Number.isFinite(rounded) ? rounded : x;
+}
 function integerPart(x) {
 	if (Number.isNaN(x)) return;
 	return String(x).split(".")[0];
@@ -59,10 +97,98 @@ function gainToDb(gain) {
 	return 20 * (Math.log(gain) / Math.LN10);
 }
 //#endregion
+//#region src/modifiers.ts
+/**
+* Checked in this order, and the first one that is both held and configured
+* wins. Fixing an order is what keeps two modifiers held at once from
+* behaving differently between browsers.
+*/
+const MODIFIER_ORDER = [
+	"meta",
+	"ctrl",
+	"alt",
+	"shift"
+];
+const MODIFIER_FLAG = {
+	meta: "metaKey",
+	ctrl: "ctrlKey",
+	alt: "altKey",
+	shift: "shiftKey"
+};
+/**
+* A map is the only form with a `default` key, which is what tells it apart
+* from a bare setting. Tuples are arrays, so they never match.
+*/
+function isModifierMap(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "default" in value;
+}
+/**
+* Pick the setting that applies, given the modifier keys being held.
+*
+* @example
+* selectModifier({ default: 1, shift: 0.1 }, event)
+*/
+function selectModifier(options, modifiers) {
+	if (!isModifierMap(options)) return {
+		value: options,
+		modifier: null
+	};
+	if (modifiers) for (const modifier of MODIFIER_ORDER) {
+		const value = options[modifier];
+		if (value !== void 0 && modifiers[MODIFIER_FLAG[modifier]]) return {
+			value,
+			modifier
+		};
+	}
+	return {
+		value: options.default,
+		modifier: null
+	};
+}
+/**
+* Turn every entry of a setting into another kind of setting, keeping which
+* modifier each belongs to.
+*
+* A drag sensitivity is a number and a keyboard amount is a tuple, but the two
+* describe the same thing from the caller's side. This carries one over to the
+* other so that a component can hand a sensitivity to {@link applyDelta}
+* without unpicking the modifier map itself — which matters, since naming a
+* modifier is also what takes `step` out of the pipeline.
+*
+* @example
+* mapModifier({ default: 1, shift: 0.1 }, (f) => ['raw', step * f])
+* // { default: ['raw', 1], shift: ['raw', 0.1] }
+*/
+function mapModifier(options, fn) {
+	if (!isModifierMap(options)) return fn(options);
+	const mapped = { default: fn(options.default) };
+	for (const modifier of MODIFIER_ORDER) {
+		const value = options[modifier];
+		if (value !== void 0) mapped[modifier] = fn(value);
+	}
+	return mapped;
+}
+/**
+* Pick the amount that applies, given the modifier keys being held.
+*
+* @example
+* selectInputEvent({ default: ['raw', 1], shift: ['raw', 0.1] }, event)
+*/
+function selectInputEvent(options, modifiers) {
+	const { value, modifier } = selectModifier(options, modifiers);
+	return {
+		option: value,
+		modifier
+	};
+}
+//#endregion
 //#region src/scales.ts
 function assertRange(min, max) {
 	if (min >= max) throw new RangeError("requirements: min < max");
 }
+function assertPositiveFinite(value, name) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name}: requirements: finite and greater than 0`);
+}
 /**
 * Equal travel gives an equal change in value.
 *
@@ -90,6 +216,7 @@ const linearScale = {
 * @param skew the JUCE skew factor
 */
 function skewScale(skew) {
+	assertPositiveFinite(skew, "skewScale");
 	return {
 		normalize: (value, min, max) => Math.pow(normalizeValue(value, min, max), skew),
 		denormalize: (position, min, max) => rawValue(skew === 1 ? position : Math.exp(Math.log(clamp(position, 0, 1)) / skew), min, max)
@@ -100,7 +227,8 @@ function skewScale(skew) {
 * of the travel — JUCE's `NormalisableRange::setSkewForCentre`.
 */
 function skewWithCenterValue(centerValue, min, max) {
-	if (!(min <= centerValue && centerValue <= max)) throw new RangeError("requirements: min <= centerValue <= max");
+	assertRange(min, max);
+	if (!(min < centerValue && centerValue < max)) throw new RangeError("requirements: min < centerValue < max");
 	return Math.log(.5) / Math.log((centerValue - min) / (max - min));
 }
 /**
@@ -117,11 +245,15 @@ function skewWithCenterValue(centerValue, min, max) {
 const exponentialScale = {
 	normalize: (value, min, max) => {
 		assertExponentialRange(min, max);
-		return clamp(Math.log(clamp(value, min, max) / min) / Math.log(max / min), 0, 1);
+		const start = Math.log(Math.abs(min));
+		const end = Math.log(Math.abs(max));
+		return clamp((Math.log(Math.abs(clamp(value, min, max))) - start) / (end - start), 0, 1);
 	},
 	denormalize: (position, min, max) => {
 		assertExponentialRange(min, max);
-		return min * Math.pow(max / min, clamp(position, 0, 1));
+		const start = Math.log(Math.abs(min));
+		const magnitude = Math.exp(start + (Math.log(Math.abs(max)) - start) * clamp(position, 0, 1));
+		return Math.sign(min) * magnitude;
 	}
 };
 function assertExponentialRange(min, max) {
@@ -150,25 +282,23 @@ function assertExponentialRange(min, max) {
 * @param curve how hard the curve bends, and in which direction
 */
 function curveScale(curve) {
+	if (!Number.isFinite(curve) || Math.abs(curve) > 32) throw new RangeError("curveScale: requirements: finite curve from -32 to 32");
 	if (Math.abs(curve) < .001) return linearScale;
-	const grow = Math.exp(curve);
-	const coefficients = (min, max) => {
-		const a = (max - min) / (1 - grow);
-		return {
-			a,
-			b: min + a
-		};
-	};
 	return {
 		normalize: (value, min, max) => {
 			assertRange(min, max);
-			const { a, b } = coefficients(min, max);
-			return clamp(Math.log((b - clamp(value, min, max)) / a) / curve, 0, 1);
+			const proportion = clamp((value - min) / (max - min), 0, 1);
+			if (proportion === 0 || proportion === 1) return proportion;
+			if (curve > 0) return 1 + Math.log(proportion + (1 - proportion) * Math.exp(-curve)) / curve;
+			return Math.log1p(proportion * Math.expm1(curve)) / curve;
 		},
 		denormalize: (position, min, max) => {
 			assertRange(min, max);
-			const { a, b } = coefficients(min, max);
-			return b - a * Math.pow(grow, clamp(position, 0, 1));
+			const p = clamp(position, 0, 1);
+			if (p === 0) return min;
+			if (p === 1) return max;
+			const proportion = curve > 0 ? Math.exp(curve * (p - 1)) * (1 - Math.exp(-curve * p)) / (1 - Math.exp(-curve)) : Math.expm1(curve * p) / Math.expm1(curve);
+			return min + (max - min) * proportion;
 		}
 	};
 }
@@ -185,6 +315,7 @@ function curveScale(curve) {
 * @param skew the JUCE skew factor
 */
 function symmetricSkewScale(skew) {
+	assertPositiveFinite(skew, "symmetricSkewScale");
 	return {
 		normalize: (value, min, max) => {
 			assertRange(min, max);
@@ -221,35 +352,33 @@ function curveWithCenterValue(centerValue, min, max) {
 * @param direction which way, and how many times, to apply the option. The
 * size of one step is `option[1]`, so this is normally `1` or `-1`.
 *
+* @param modifiers the event, for `options` that name a modifier key. See
+* {@link selectInputEvent}.
+*
 * @example
 * // ArrowDown on a slider whose keyboard option is ['raw', 1]
 * applyDelta(value, -1, keyboard, { min, max, step, scale })
+*
+* @example
+* // Shift+ArrowDown, where `keyboard` is { default: …, shift: ['raw', 0.1] }
+* applyDelta(value, -1, keyboard, range, event)
 */
-function applyDelta(value, direction, [mode, amount], { min, max, step, scale = linearScale }) {
+function applyDelta(value, direction, options, { min, max, step, scale = linearScale }, modifiers) {
+	assertRange(min, max);
+	if (step !== void 0) assertPositiveFinite(step, "applyDelta step");
+	const { option: [mode, amount], modifier } = selectInputEvent(options, modifiers);
 	const x = direction * amount;
-	const next = mode == "normalized" ? scale.denormalize(scale.normalize(value, min, max) + x, min, max) : value + x;
-	return clamp(step ? stepValue(next, step) : next, min, max);
+	const next = mode === "normalized" ? scale.denormalize(scale.normalize(value, min, max) + x, min, max) : value + x;
+	const quantum = modifier === null ? step : void 0;
+	return clamp(toPrecision(quantum !== void 0 ? stepValue(next, quantum) : next), min, max);
 }
 //#endregion
 //#region src/util.ts
-function styleHelper(value, op, influencer) {
-	if (op && influencer) if (typeof value == "number") {
-		if (op == "+") return `${value + influencer}px`;
-		if (op == "-") return `${value - influencer}px`;
-		if (op == "*") return `${value * influencer}px`;
-		if (op == "/") return `${value / influencer}px`;
-	} else return `calc(${value}px ${op} ${influencer})`;
-	else if (typeof value == "number") return `${value}px`;
-	else return value;
-}
-function isEmpty(obj) {
-	return Object.keys(obj).length == 0;
-}
 function mod(n, m) {
 	return (n % m + m) % m;
 }
 function xor(a = false, b = false) {
-	return (a || b) && a != b;
+	return (a || b) && a !== b;
 }
 //#endregion
 //#region src/midi.ts
@@ -276,14 +405,19 @@ const noteKeys = [
 	"A#",
 	"B"
 ];
+function assertSafeInteger(value, name) {
+	if (!Number.isSafeInteger(value)) throw new RangeError(`${name}: requirements: a safe integer`);
+}
 function parseNoteName(noteName) {
 	const m = noteName.match(/^([a-g])(#{0,2}|b{0,2})(-?\d+)$/i);
 	if (!m) throw new Error("Invalid note name");
 	const [, letter, accidental, octave] = m;
+	const parsedOctave = Number(octave);
+	assertSafeInteger(parsedOctave, "octave");
 	return {
 		letter: letter.toLocaleUpperCase(),
 		accidental,
-		octave: Number(octave)
+		octave: parsedOctave
 	};
 }
 /**
@@ -292,8 +426,10 @@ function parseNoteName(noteName) {
 function noteNumber(noteName) {
 	const { letter, accidental, octave } = parseNoteName(noteName);
 	const noteIndex = noteKeys.indexOf(letter.toLocaleUpperCase());
-	const accidentalValue = (accidental[0] == "b" ? -1 : 1) * accidental.length;
-	return noteIndex + 12 * (Number(octave) + 1) + accidentalValue;
+	const accidentalValue = (accidental[0] === "b" ? -1 : 1) * accidental.length;
+	const result = noteIndex + 12 * (octave + 1) + accidentalValue;
+	assertSafeInteger(result, "note number");
+	return result;
 }
 /**
 * Convert noteNumber to noteName
@@ -302,6 +438,7 @@ function noteNumber(noteName) {
 * @param noteNumber noteNumber
 */
 function noteName(noteNumber) {
+	assertSafeInteger(noteNumber, "note number");
 	const noteIndex = mod(noteNumber, 12);
 	const octave = Math.floor(noteNumber / 12) - 1;
 	return `${noteKeys[noteIndex]}${octave}`;
@@ -310,14 +447,16 @@ function noteName(noteNumber) {
 * Convert noteNumber to noteKey
 */
 function noteKey(noteNumber) {
+	assertSafeInteger(noteNumber, "note number");
 	return noteKeys[mod(noteNumber, 12)];
 }
 /**
 * @param note noteNumber: 0 ~ 127 or noteName e.g. 'C3'
 */
 function isWhiteKey(note) {
-	const n = typeof note == "string" ? noteNumber(note) : note;
-	return mod(n, 12) == 0 || mod(n, 12) == 2 || mod(n, 12) == 4 || mod(n, 12) == 5 || mod(n, 12) == 7 || mod(n, 12) == 9 || mod(n, 12) == 11;
+	const n = typeof note === "string" ? noteNumber(note) : note;
+	assertSafeInteger(n, "note number");
+	return mod(n, 12) === 0 || mod(n, 12) === 2 || mod(n, 12) === 4 || mod(n, 12) === 5 || mod(n, 12) === 7 || mod(n, 12) === 9 || mod(n, 12) === 11;
 }
 /**
 * @param note noteNumber: 0 ~ 127 or noteName e.g. 'C3'
@@ -332,7 +471,8 @@ function isBlackKey(note) {
 * @returns frequency [Hz]
 */
 function noteToFrequency(note, detune = 0, a4 = 440) {
-	const n = typeof note == "string" ? noteNumber(note) : note;
+	const n = typeof note === "string" ? noteNumber(note) : note;
+	assertSafeInteger(n, "note number");
 	return a4 / 32 * 2 ** ((n - 9 + detune / 100) / 12);
 }
 /**
@@ -503,8 +643,10 @@ const scaleIntervals = {
 * ```
 */
 function inScale(note, root, name) {
-	const n = typeof note == "string" ? noteNumber(note) : note;
-	const r = typeof root == "string" ? noteNumber(root) : root;
+	const n = typeof note === "string" ? noteNumber(note) : note;
+	const r = typeof root === "string" ? noteNumber(root) : root;
+	assertSafeInteger(n, "note number");
+	assertSafeInteger(r, "root note number");
 	return scaleIntervals[name].includes(mod(n - r, 12));
 }
 /**
@@ -522,7 +664,9 @@ function inScale(note, root, name) {
 * ```
 */
 function scaleNotes(root, name, octaves = 1) {
-	const r = typeof root == "string" ? noteNumber(root) : root;
+	const r = typeof root === "string" ? noteNumber(root) : root;
+	assertSafeInteger(r, "root note number");
+	if (!Number.isSafeInteger(octaves) || octaves < 0) throw new RangeError("octaves: requirements: a non-negative safe integer");
 	const intervals = scaleIntervals[name];
 	return Array.from({ length: octaves }, (_, octave) => intervals.map((interval) => r + octave * 12 + interval)).flat();
 }
@@ -562,10 +706,39 @@ const whiteKeysBefore = {
 function blackKeyWidth(layout) {
 	return layout.whiteKeyWidth * (layout.blackKeyWidthRatio ?? DEFAULT_BLACK_KEY_WIDTH_RATIO);
 }
+function rawNotePosition(note, layout) {
+	const slot = layout.whiteKeyWidth + (layout.keyGap ?? DEFAULT_KEY_GAP);
+	const target = noteKey(note);
+	const first = noteKey(layout.noteRange.first);
+	const octave = Math.floor((note - layout.noteRange.first) / 12);
+	const octaveOffset = noteKeys.indexOf(first) > noteKeys.indexOf(target) ? 1 : 0;
+	const whiteKeysIn = whiteKeysBefore[target] - whiteKeysBefore[first] + (octave + octaveOffset) * 7;
+	return isBlackKey(note) ? whiteKeysIn * slot - blackKeyWidth(layout) / 2 : whiteKeysIn * slot;
+}
+function pianoBounds(layout) {
+	const notes = getNoteRangeArray(layout.noteRange);
+	if (notes.length === 0) return {
+		left: 0,
+		right: 0
+	};
+	let left = Infinity;
+	let right = -Infinity;
+	const whiteWidth = layout.whiteKeyWidth + (layout.keyGap ?? DEFAULT_KEY_GAP);
+	for (const note of notes) {
+		const noteLeft = rawNotePosition(note, layout);
+		const width = isBlackKey(note) ? blackKeyWidth(layout) : whiteWidth;
+		left = Math.min(left, noteLeft);
+		right = Math.max(right, noteLeft + width);
+	}
+	return {
+		left,
+		right
+	};
+}
 /** Width of the whole keyboard in pixels. */
 function pianoWidth(layout) {
-	const whiteKeys = getNoteRangeArray(layout.noteRange).filter(isWhiteKey);
-	return (layout.whiteKeyWidth + (layout.keyGap ?? DEFAULT_KEY_GAP)) * whiteKeys.length;
+	const { left, right } = pianoBounds(layout);
+	return right - left;
 }
 /**
 * Offset of the left edge of a key from the left edge of the keyboard, in
@@ -575,13 +748,7 @@ function pianoWidth(layout) {
 * `noteRange.first`.
 */
 function notePosition(note, layout) {
-	const slot = layout.whiteKeyWidth + (layout.keyGap ?? DEFAULT_KEY_GAP);
-	const target = noteKey(note);
-	const first = noteKey(layout.noteRange.first);
-	const octave = Math.floor((note - layout.noteRange.first) / 12);
-	const octaveOffset = noteKeys.indexOf(first) > noteKeys.indexOf(target) ? 1 : 0;
-	const whiteKeysIn = whiteKeysBefore[target] - whiteKeysBefore[first] + (octave + octaveOffset) * 7;
-	return isBlackKey(note) ? whiteKeysIn * slot - blackKeyWidth(layout) / 2 : whiteKeysIn * slot;
+	return rawNotePosition(note, layout) - pianoBounds(layout).left;
 }
 /**
 * The note drawn at a point, or null where there is none.
@@ -595,7 +762,7 @@ function notePosition(note, layout) {
 * @param height height of the keyboard, in pixels
 */
 function noteAt(x, y, height, layout) {
-	if (y < 0 || y >= height) return null;
+	if (x < 0 || x >= pianoWidth(layout) || y < 0 || y >= height) return null;
 	const notes = getNoteRangeArray(layout.noteRange);
 	if (y < height * (layout.blackKeyHeightRatio ?? DEFAULT_BLACK_KEY_HEIGHT_RATIO)) for (const note of notes) {
 		if (isWhiteKey(note)) continue;
@@ -612,56 +779,121 @@ function noteAt(x, y, height, layout) {
 }
 //#endregion
 //#region src/unit.ts
+/** Ordered small to large. The empty symbol is the base unit. */
+const PREFIXES = [
+	["p", 1e-12],
+	["n", 1e-9],
+	["µ", 1e-6],
+	["m", .001],
+	["", 1],
+	["k", 1e3],
+	["M", 1e6],
+	["G", 1e9]
+];
+const PREFIX_SCALE = new Map(PREFIXES);
 /**
-* Pick the unit a value is displayed in: the largest one whose scale does not
-* exceed the magnitude of the value.
+* Micro is written three ways. `µ` (U+00B5 MICRO SIGN) is what `format`
+* writes and what d3-format uses, `μ` (U+03BC GREEK SMALL LETTER MU) looks
+* identical and is what a Greek keyboard produces, and `u` is what everyone
+* actually types. All three read back the same.
 */
-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)];
-}
+const MICRO_ALIASES = {
+	μ: "µ",
+	u: "µ"
+};
 /**
-* Render a value as text, in the unit that suits its magnitude.
-*
-* @param units a single symbol appended as-is, or a list to choose from.
-* @param digit digits after the decimal point. Left as-is when omitted.
+* Divide by a prefix scale without showing the result of doing so in binary.
 *
-* @example
-* formatValue(1234, [['Hz', 1], ['kHz', 1000]], 2) // '1.23kHz'
-* formatValue(1.5, 'Hz')                           // '1.5Hz'
+* `0.0005 / 1e-6` is 500.00000000000006, and with no `digits` to round it that
+* lands in the input as written.
 */
-function formatValue(value, units, digit) {
-	const fixed = (v) => digit != void 0 ? v.toFixed(digit) : String(v);
-	if (!units || typeof units == "string") return fixed(value) + (units ?? "");
-	const [unit, scale] = selectUnit(units, value);
-	return fixed(value / scale) + unit;
+function scaleBy(value, scale) {
+	return toPrecision(value / scale);
 }
+/** A number, then whatever followed it. */
+const NUMBER_THEN_REST = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(.*)$/;
 /**
-* Read a value back out of text, undoing the scaling of {@link formatValue}.
+* Build the `format` and `parse` of a unit, as one pair.
+*
+* They are returned together because they have to agree: a `format` that
+* writes `1.23kHz` is only useful next to a `parse` that reads it back as
+* 1230. Spread the result into the input.
 *
-* With a list of units the text has to be a number followed by an optional
-* unit and nothing else, since the unit decides the scale; anything else reads
-* as 0. With a single unit, or none, the first number found anywhere in the
-* text is taken, so a half-typed entry still yields something.
+* @example
+* unitFormat('Hz')                                 // 1234 -> '1.23kHz'
+* unitFormat('s', { base: 'm' })                   // value in ms. 1500 -> '1.5s'
+* unitFormat('s', { base: 'm', digits: 2 })        // 1500 -> '1.50s'
+* unitFormat('dB', { prefixes: false, digits: 1 }) // -6.25 -> '-6.3dB'
 *
 * @example
-* parseValue('1.23kHz', [['Hz', 1], ['kHz', 1000]]) // 1230
-* parseValue('4abc')                                // 4
-*/
-function parseValue(text, units) {
-	const str = text.trim();
-	if (!units || typeof units == "string") {
-		const m = str.match(/-?\d+(\.\d+)?/);
-		const v = Number(m?.[0] ?? "0");
-		return isNaN(v) ? 0 : v;
+* <NumberInput.Root {...unitFormat('Hz', { digits: 2 })} value={v} onChange={setV}>
+*/
+function unitFormat(unit, options = {}) {
+	const { base = "", prefixes = true, digits, separator = "" } = options;
+	if (unit === "" && base !== "") throw new RangeError("unitFormat: base requires a non-empty unit");
+	const baseScale = PREFIX_SCALE.get(base) ?? 1;
+	/**
+	* `toFixed` renders anything that rounds to zero from below as `-0`, which
+	* is never what a control should show.
+	*/
+	const fixed = (value) => {
+		const text = digits !== void 0 ? value.toFixed(digits) : String(value);
+		return Number(text) === 0 ? text.replace("-", "") : text;
+	};
+	if (!prefixes) {
+		const symbol = base + unit;
+		return {
+			format: (value) => Number.isFinite(value) ? fixed(value) + separator + symbol : String(value),
+			parse: (text) => {
+				const match = text.trim().match(NUMBER_THEN_REST);
+				if (!match) return NaN;
+				const value = Number(match[1]);
+				return Number.isFinite(value) ? value : NaN;
+			}
+		};
 	}
-	const m = str.match(/^(-?\d+(\.\d+)?)\s*(\w*)$/);
-	if (!m) return 0;
-	const found = units.find(([unit]) => unit == m[3]);
-	return (Number(m[1]) || 0) * (found ? found[1] : 1);
+	return {
+		format: (value) => {
+			if (!Number.isFinite(value)) return String(value);
+			const si = value * baseScale;
+			let index = PREFIXES.findIndex(([, scale]) => scale === 1);
+			if (si !== 0) {
+				const magnitude = Math.abs(si);
+				index = 0;
+				for (let i = PREFIXES.length - 1; i >= 0; i--) if (magnitude >= PREFIXES[i][1]) {
+					index = i;
+					break;
+				}
+			}
+			let text = fixed(scaleBy(si, PREFIXES[index][1]));
+			if (Math.abs(Number(text)) >= 1e3 && index < PREFIXES.length - 1) {
+				index += 1;
+				text = fixed(scaleBy(si, PREFIXES[index][1]));
+			}
+			return text + separator + PREFIXES[index][0] + unit;
+		},
+		parse: (text) => {
+			const match = text.trim().match(NUMBER_THEN_REST);
+			if (!match) return NaN;
+			const number = Number(match[1]);
+			if (!Number.isFinite(number)) return NaN;
+			let suffix = match[2].trim();
+			const separatorText = separator.trim();
+			if (separatorText !== "" && suffix.startsWith(separatorText)) suffix = suffix.slice(separatorText.length).trim();
+			if (suffix === "") return number;
+			let prefix = null;
+			if (unit !== "" && suffix.endsWith(unit)) prefix = suffix.slice(0, suffix.length - unit.length);
+			else if (suffix.length <= 1) prefix = suffix;
+			if (prefix === null) return number;
+			const normalized = MICRO_ALIASES[prefix] ?? prefix;
+			const scale = PREFIX_SCALE.get(normalized);
+			if (scale === void 0) return number;
+			return number * scale / baseScale;
+		}
+	};
 }
 //#endregion
+exports.SIGNIFICANT_DIGITS = SIGNIFICANT_DIGITS;
 exports.applyDelta = applyDelta;
 exports.blackKeyWidth = blackKeyWidth;
 exports.clamp = clamp;
@@ -671,15 +903,14 @@ exports.dbToGain = dbToGain;
 exports.decimalPart = decimalPart;
 exports.degree = degree;
 exports.exponentialScale = exponentialScale;
-exports.formatValue = formatValue;
 exports.gainToDb = gainToDb;
 exports.getNoteRangeArray = getNoteRangeArray;
 exports.inScale = inScale;
 exports.integerPart = integerPart;
 exports.isBlackKey = isBlackKey;
-exports.isEmpty = isEmpty;
 exports.isWhiteKey = isWhiteKey;
 exports.linearScale = linearScale;
+exports.mapModifier = mapModifier;
 exports.mapValue = mapValue;
 exports.mod = mod;
 exports.normalizeValue = normalizeValue;
@@ -691,19 +922,20 @@ exports.noteNumber = noteNumber;
 exports.notePosition = notePosition;
 exports.noteToFrequency = noteToFrequency;
 exports.parseNoteName = parseNoteName;
-exports.parseValue = parseValue;
 exports.pianoWidth = pianoWidth;
 exports.radian = radian;
 exports.rawValue = rawValue;
 exports.scaleIntervals = scaleIntervals;
 exports.scaleNotes = scaleNotes;
-exports.selectUnit = selectUnit;
+exports.selectInputEvent = selectInputEvent;
+exports.selectModifier = selectModifier;
 exports.skewScale = skewScale;
 exports.skewWithCenterValue = skewWithCenterValue;
 exports.stepValue = stepValue;
-exports.styleHelper = styleHelper;
 exports.symmetricSkewScale = symmetricSkewScale;
 exports.toFixed = toFixed;
+exports.toPrecision = toPrecision;
+exports.unitFormat = unitFormat;
 exports.whiteKeys = whiteKeys;
 exports.xor = xor;