@tremolo-ui/functions 0.5.0 → 0.7.0

package/dist/index.js

@@ -24,23 +24,54 @@ 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));
 }
-function integerPart(x) {
-	if (Number.isNaN(x)) return;
-	return String(x).split(".")[0];
-}
-function decimalPart(x) {
-	return String(x).split(".")[1];
+/**
+* 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 = SIGNIFICANT_DIGITS) {
+	if (x === 0 || !Number.isFinite(x)) return x;
+	const rounded = Number(x.toPrecision(significantDigits));
+	return Number.isFinite(rounded) ? rounded : x;
 }
 function radian(degree) {
 	return Math.PI * degree / 180;
@@ -62,6 +93,9 @@ function gainToDb(gain) {
 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.
 *
@@ -89,6 +123,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)
@@ -99,7 +134,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));
 }
 /**
@@ -116,11 +152,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) {
@@ -149,25 +189,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;
 		}
 	};
 }
@@ -184,6 +222,7 @@ function curveScale(curve) {
 * @param skew the JUCE skew factor
 */
 function symmetricSkewScale(skew) {
+	assertPositiveFinite(skew, "symmetricSkewScale");
 	return {
 		normalize: (value, min, max) => {
 			assertRange(min, max);
@@ -210,48 +249,18 @@ function curveWithCenterValue(centerValue, min, max) {
 	const proportion = (centerValue - min) / (max - min);
 	return 2 * Math.log(1 / proportion - 1);
 }
+//#endregion
+//#region src/midi.ts
 /**
-* Move a value by an amount of input, as reported by a wheel or an arrow key.
-*
-* The pipeline matches `createDragValue` of `@tremolo-ui/dom`: scale, then
-* step, then clamp. Which key or which sign of `deltaY` counts as which
-* direction is left to the caller, since it differs per component.
+* Remainder that follows the sign of the divisor, rather than of the dividend.
 *
-* @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`.
-*
-* @example
-* // ArrowDown on a slider whose keyboard option is ['raw', 1]
-* applyDelta(value, -1, keyboard, { min, max, step, scale })
+* `%` in JavaScript keeps the sign of the left operand, so `-13 % 12` is `-1`
+* and cannot index a 12-element table. Every note here is placed by its
+* position within the octave, and note numbers below C-1 are negative.
 */
-function applyDelta(value, direction, [mode, amount], { min, max, step, scale = linearScale }) {
-	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);
-}
-//#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;
-}
-//#endregion
-//#region src/midi.ts
 const whiteKeys = [
 	"A",
 	"B",
@@ -275,14 +284,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
 	};
 }
 /**
@@ -291,8 +305,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
@@ -301,6 +317,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}`;
@@ -309,14 +326,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'
@@ -331,7 +350,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);
 }
 /**
@@ -502,8 +522,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));
 }
 /**
@@ -521,146 +543,128 @@ 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();
 }
 //#endregion
-//#region src/piano.ts
-/**
-* `[noteRange.first, noteRange.first + 1, ..., noteRange.last]`
-*/
-function getNoteRangeArray(noteRange) {
-	return Array.from({ length: noteRange.last - noteRange.first + 1 }, (_, i) => i + noteRange.first);
-}
-const DEFAULT_KEY_GAP = 1;
-const DEFAULT_BLACK_KEY_WIDTH_RATIO = .65;
-const DEFAULT_BLACK_KEY_HEIGHT_RATIO = .6;
+//#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);
 /**
-* How many white keys sit at or before each pitch class, counting from C.
-*
-* A black key shares the number of the white key to its left plus one, which
-* puts it on the boundary between the two; {@link notePosition} then shifts it
-* back by half its width to centre it there.
+* 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.
 */
-const whiteKeysBefore = {
-	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 MICRO_ALIASES = {
+	μ: "µ",
+	u: "µ"
 };
-/** Width of a black key in pixels. */
-function blackKeyWidth(layout) {
-	return layout.whiteKeyWidth * (layout.blackKeyWidthRatio ?? DEFAULT_BLACK_KEY_WIDTH_RATIO);
-}
-/** 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;
-}
 /**
-* Offset of the left edge of a key from the left edge of the keyboard, in
-* pixels.
+* Divide by a prefix scale without showing the result of doing so in binary.
 *
-* Notes outside `noteRange` are placed too, so the value is negative below
-* `noteRange.first`.
+* `0.0005 / 1e-6` is 500.00000000000006, and with no `digits` to round it that
+* lands in the input as written.
 */
-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;
+function scaleBy(value, scale) {
+	return toPrecision(value / scale);
 }
+/** A number, then whatever followed it. */
+const NUMBER_THEN_REST = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(.*)$/;
 /**
-* The note drawn at a point, or null where there is none.
+* Build the `format` and `parse` of a unit, as one pair.
 *
-* Black keys are tested first, so they win where they overlap a white one. A
-* white key covers its gap as well as its width, so the whole width of the
-* keyboard belongs to some key and a click cannot fall between two.
-*
-* @param x offset from the left edge of the keyboard, in pixels
-* @param y offset from its top edge, in pixels
-* @param height height of the keyboard, in pixels
-*/
-function noteAt(x, y, height, layout) {
-	if (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;
-		const left = notePosition(note, layout);
-		if (left <= x && x < left + blackKeyWidth(layout)) return note;
-	}
-	const slot = layout.whiteKeyWidth + (layout.keyGap ?? DEFAULT_KEY_GAP);
-	for (const note of notes) {
-		if (isBlackKey(note)) continue;
-		const left = notePosition(note, layout);
-		if (left <= x && x < left + slot) return note;
-	}
-	return null;
-}
-//#endregion
-//#region src/unit.ts
-/**
-* Pick the unit a value is displayed in: the largest one whose scale does not
-* exceed the magnitude of the value.
-*/
-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)];
-}
-/**
-* 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.
+* 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.
 *
 * @example
-* formatValue(1234, [['Hz', 1], ['kHz', 1000]], 2) // '1.23kHz'
-* formatValue(1.5, 'Hz')                           // '1.5Hz'
-*/
-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;
-}
-/**
-* Read a value back out of text, undoing the scaling of {@link formatValue}.
-*
-* 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.
+* 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
+* <NumberInput.Root {...unitFormat('Hz', { digits: 2 })} value={v} onChange={setV}>
 */
-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;
+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
-export { applyDelta, blackKeyWidth, clamp, curveScale, curveWithCenterValue, dbToGain, decimalPart, degree, exponentialScale, formatValue, gainToDb, getNoteRangeArray, inScale, integerPart, isBlackKey, isEmpty, isWhiteKey, linearScale, mapValue, mod, normalizeValue, noteAt, noteKey, noteKeys, noteName, noteNumber, notePosition, noteToFrequency, parseNoteName, parseValue, pianoWidth, radian, rawValue, scaleIntervals, scaleNotes, selectUnit, skewScale, skewWithCenterValue, stepValue, styleHelper, symmetricSkewScale, toFixed, whiteKeys, xor };
+export { clamp, curveScale, curveWithCenterValue, dbToGain, degree, exponentialScale, gainToDb, inScale, isBlackKey, isWhiteKey, linearScale, mapValue, normalizeValue, noteKey, noteKeys, noteName, noteNumber, noteToFrequency, parseNoteName, radian, rawValue, scaleIntervals, scaleNotes, skewScale, skewWithCenterValue, stepValue, symmetricSkewScale, toFixed, toPrecision, unitFormat, whiteKeys };
 
 //# sourceMappingURL=index.js.map