@tremolo-ui/functions 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -4,16 +4,57 @@
  */
 declare function clamp(value: number, min: number, max: number): number;
 /**
- * Normalize the value from 0 to 1
+ * Normalize the value from 0 to 1, spreading the range evenly.
+ *
+ * This is the linear mapping and takes no curve of its own; a `Scale` builds
+ * whatever curve it needs on top of it.
  */
-declare function normalizeValue(rawValue: number, min: number, max: number, skew?: number): number;
+declare function normalizeValue(value: number, min: number, max: number): number;
 /**
- * Convert normalized values back to raw values.
+ * Convert normalized values back to raw values, spreading the range evenly.
+ *
+ * The inverse of {@link normalizeValue}.
+ */
+declare function rawValue(normalizedValue: number, min: number, max: number): number;
+/**
+ * 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.
  */
-declare function rawValue(normalizedValue: number, min: number, max: number, skew?: number): number;
-declare function skewWithCenterValue(centerValue: number, min: number, max: number): number;
 declare function stepValue(value: number, step: number): number;
 declare function toFixed(x: number, fractionDigits?: number): number;
+/**
+ * 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.
+ */
+declare 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
+ */
+declare function toPrecision(x: number, significantDigits?: number): number;
 declare function integerPart(x: number | string): string | undefined;
 declare function decimalPart(x: number | string): string | undefined;
 declare function radian(degree: number): number;
@@ -22,6 +63,224 @@ declare function mapValue(value: number, inMin: number, inMax: number, outMin: n
 declare function dbToGain(db: number): number;
 declare function gainToDb(gain: number): number;
 //#endregion
+//#region src/modifiers.d.ts
+/**
+ * Options for setting the amount of keyboard and mouse wheel changes.
+ */
+type InputEventOption = readonly ['normalized' | 'raw', number];
+/**
+ * A modifier key that can carry an amount of its own.
+ *
+ * `ctrl` and `meta` are kept apart rather than folded into one "command" key:
+ * a plugin UI that mirrors a desktop host usually wants the same physical key
+ * on every platform, not the platform's own convention.
+ */
+type Modifier = 'shift' | 'alt' | 'ctrl' | 'meta';
+/** The modifier flags of a `WheelEvent` or a `KeyboardEvent`. */
+interface ModifierState {
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+}
+/** One setting per modifier key, with `default` for none of them. */
+type ModifierSetting = number | InputEventOption;
+type ModifierMap<T extends ModifierSetting> = {
+  default: T;
+} & Partial<Record<Modifier, T>>;
+/**
+ * A single setting, or one per modifier key.
+ *
+ * @example
+ * ['raw', 1]
+ * { default: ['raw', 1], shift: ['raw', 0.1] }
+ */
+type ModifierValue<T extends ModifierSetting> = T | ModifierMap<T>;
+interface SelectedInputEvent {
+  option: InputEventOption;
+  /** Which modifier entry was chosen, or `null` for `default`. */
+  modifier: Modifier | null;
+}
+/**
+ * Pick the setting that applies, given the modifier keys being held.
+ *
+ * @example
+ * selectModifier({ default: 1, shift: 0.1 }, event)
+ */
+declare function selectModifier<T extends ModifierSetting>(options: ModifierValue<T>, modifiers?: ModifierState): {
+  value: T;
+  modifier: Modifier | null;
+};
+/**
+ * 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] }
+ */
+declare function mapModifier<T extends ModifierSetting, U extends ModifierSetting>(options: ModifierValue<T>, fn: (value: T) => U): ModifierValue<U>;
+/**
+ * Pick the amount that applies, given the modifier keys being held.
+ *
+ * @example
+ * selectInputEvent({ default: ['raw', 1], shift: ['raw', 0.1] }, event)
+ */
+declare function selectInputEvent(options: ModifierValue<InputEventOption>, modifiers?: ModifierState): SelectedInputEvent;
+//#endregion
+//#region src/scales.d.ts
+/**
+ * How a value is distributed across the travel of a control.
+ *
+ * `normalize` and `denormalize` are inverses of each other: the position is
+ * 0 at `min` and 1 at `max`, and everything in between is up to the scale.
+ *
+ * `min` and `max` are arguments rather than baked into the scale, so a scale
+ * holds no state and can be a module level constant. Passing the same object
+ * on every render therefore costs nothing.
+ *
+ * @example
+ * ```ts
+ * exponentialScale.denormalize(0.5, 20, 20000) // 632.45…
+ * ```
+ */
+interface Scale {
+  /** Value to its position on the travel, 0-1. */
+  normalize: (value: number, min: number, max: number) => number;
+  /** Position on the travel, 0-1, back to a value. */
+  denormalize: (position: number, min: number, max: number) => number;
+}
+/**
+ * Equal travel gives an equal change in value.
+ *
+ * The right default for anything already linear in perception: dB values,
+ * pan, percentages, MIDI note numbers, semitones.
+ */
+declare const linearScale: Scale;
+/**
+ * The power law of JUCE's `NormalisableRange::skew`, applied to `value - min`.
+ *
+ * Use it when the value has to agree with a JUCE or iPlug2 parameter — a
+ * plugin UI in a WebView, say, where the knob must sit exactly where the
+ * host's automation curve puts it. {@link skewWithCenterValue} gives the
+ * factor that places a chosen value at the middle of the travel.
+ *
+ * `skew < 1` gives the lower end more travel, `skew > 1` the upper end.
+ *
+ * For new designs prefer {@link exponentialScale} or {@link curveScale}: the
+ * slope of this curve is either zero or infinite at `min`, so the bottom of
+ * the range is a dead zone or jumps.
+ *
+ * @param skew the JUCE skew factor
+ */
+declare function skewScale(skew: number): Scale;
+/**
+ * The skew factor for {@link skewScale} that puts `centerValue` at the middle
+ * of the travel — JUCE's `NormalisableRange::setSkewForCentre`.
+ */
+declare function skewWithCenterValue(centerValue: number, min: number, max: number): number;
+/**
+ * Equal travel gives an equal *ratio*, so an octave — or a percentage — takes
+ * the same distance wherever it falls.
+ *
+ * The scale for frequency (a filter cutoff over 20-20000 Hz), free running
+ * rates, and delay times.
+ *
+ * Requires `min` and `max` to be non-zero and of the same sign, since no
+ * ratio reaches zero or crosses it. Use {@link curveScale} for a range that
+ * starts at 0.
+ */
+declare const exponentialScale: Scale;
+/**
+ * An exponential bend that still passes exactly through `min` and `max`, so
+ * unlike {@link exponentialScale} it works on a range that starts at 0 or
+ * crosses it, and unlike {@link skewScale} its slope is neither zero nor
+ * infinite at either end.
+ *
+ * The general purpose taper, and the same family as the curve of an envelope
+ * segment (SuperCollider's `CurveWarp`).
+ *
+ * - `curve > 0` gives the lower end more travel — envelope times from 0 ms,
+ *   delay times, anything that wants fine control near the bottom
+ * - `curve < 0` gives the upper end more travel — a volume fader over
+ *   -60..+6 dB that should be precise around 0 dB
+ * - near 0 it is indistinguishable from {@link linearScale}, and is treated
+ *   as linear to avoid dividing by zero
+ *
+ * {@link curveWithCenterValue} gives the curve that places a chosen value at
+ * the middle of the travel.
+ *
+ * @param curve how hard the curve bends, and in which direction
+ */
+declare function curveScale(curve: number): Scale;
+/**
+ * {@link skewScale} mirrored about the middle of the range, so both halves
+ * bend the same way — JUCE's `symmetricSkew`.
+ *
+ * For a bipolar control whose centre matters: detune over -100..+100 cents,
+ * or a bipolar filter envelope amount, where the fine adjustment is around 0
+ * rather than at either end.
+ *
+ * `skew < 1` gives the middle more travel, `skew > 1` the two ends.
+ *
+ * @param skew the JUCE skew factor
+ */
+declare function symmetricSkewScale(skew: number): Scale;
+/**
+ * The curve for {@link curveScale} that puts `centerValue` at the middle of
+ * the travel — the counterpart of {@link skewWithCenterValue}.
+ */
+declare function curveWithCenterValue(centerValue: number, min: number, max: number): number;
+/**
+ * How a value is scaled: the range it lives in, how it is rounded, and how it
+ * is distributed across the travel.
+ *
+ * `AxisOptions` of `@tremolo-ui/dom` extends this, so a drag and a
+ * wheel / keyboard nudge run the same value pipeline.
+ */
+interface ValueRange {
+  min: number;
+  max: number;
+  /**
+   * Rounding applied to the value. Left unrounded when omitted.
+   */
+  step?: number;
+  /**
+   * How the value is distributed across the travel.
+   *
+   * @default linearScale
+   */
+  scale?: Scale;
+}
+/**
+ * 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.
+ *
+ * @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)
+ */
+declare function applyDelta(value: number, direction: number, options: ModifierValue<InputEventOption>, { min, max, step, scale }: ValueRange, modifiers?: ModifierState): number;
+//#endregion
 //#region src/midi.d.ts
 declare const whiteKeys: readonly ["A", "B", "C", "D", "E", "F", "G"];
 type WhiteKey = (typeof whiteKeys)[number];
@@ -62,20 +321,193 @@ declare function isBlackKey(note: number | string): boolean;
  * @returns frequency [Hz]
  */
 declare function noteToFrequency(note: number | string, detune?: number, a4?: number): number;
+/**
+ * Semitones above the root, for each supported scale.
+ *
+ * Every entry starts at 0 and stays inside one octave, so a scale is a set of
+ * pitch classes rather than a set of notes: {@link inScale} compares against
+ * it with the octave taken out.
+ *
+ * `ionian` and `aeolian` are the same sets as `major` and `naturalMinor`; both
+ * spellings are here because both are what someone reaches for depending on
+ * whether they are thinking in keys or in modes.
+ */
+declare const scaleIntervals: {
+  readonly major: readonly [0, 2, 4, 5, 7, 9, 11];
+  readonly naturalMinor: readonly [0, 2, 3, 5, 7, 8, 10];
+  readonly harmonicMinor: readonly [0, 2, 3, 5, 7, 8, 11];
+  readonly melodicMinor: readonly [0, 2, 3, 5, 7, 9, 11];
+  readonly ionian: readonly [0, 2, 4, 5, 7, 9, 11];
+  readonly dorian: readonly [0, 2, 3, 5, 7, 9, 10];
+  readonly phrygian: readonly [0, 1, 3, 5, 7, 8, 10];
+  readonly lydian: readonly [0, 2, 4, 6, 7, 9, 11];
+  readonly mixolydian: readonly [0, 2, 4, 5, 7, 9, 10];
+  readonly aeolian: readonly [0, 2, 3, 5, 7, 8, 10];
+  readonly locrian: readonly [0, 1, 3, 5, 6, 8, 10];
+  readonly majorPentatonic: readonly [0, 2, 4, 7, 9];
+  readonly minorPentatonic: readonly [0, 3, 5, 7, 10];
+  readonly blues: readonly [0, 3, 5, 6, 7, 10];
+  readonly wholeTone: readonly [0, 2, 4, 6, 8, 10];
+  readonly chromatic: readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+};
+type ScaleName = keyof typeof scaleIntervals;
+/**
+ * Whether a note belongs to a scale, regardless of the octave either sits in.
+ *
+ * @param note noteNumber: 0 ~ 127 or noteName e.g. 'C3'
+ * @param root the note the scale is built on, in the same two forms
+ *
+ * @example
+ * ```ts
+ * inScale('F#4', 'D3', 'major') // true
+ * ```
+ */
+declare function inScale(note: number | string, root: number | string, name: ScaleName): boolean;
+/**
+ * The notes of a scale, ascending from `root`.
+ *
+ * The octave above the root is not included: ask for more `octaves` instead, so
+ * that concatenating the result of two calls does not repeat a note.
+ *
+ * @param root noteNumber: 0 ~ 127 or noteName e.g. 'C3'
+ * @param octaves how many octaves to cover
+ *
+ * @example
+ * ```ts
+ * scaleNotes('C3', 'majorPentatonic') // [48, 50, 52, 55, 57]
+ * ```
+ */
+declare function scaleNotes(root: number | string, name: ScaleName, octaves?: number): number[];
 //#endregion
-//#region src/types.d.ts
+//#region src/piano.d.ts
+type NoteRange = {
+  first: number;
+  last: number;
+};
 /**
- * Options for setting the amount of keyboard and mouse wheel changes.
+ * `[noteRange.first, noteRange.first + 1, ..., noteRange.last]`
+ */
+declare function getNoteRangeArray(noteRange: NoteRange): number[];
+/**
+ * The geometry of a drawn keyboard.
+ *
+ * One description is shared by the drawing and the hit testing, so a key cannot
+ * be drawn somewhere other than where it responds.
+ */
+interface PianoLayout {
+  noteRange: NoteRange;
+  /** Width of a white key, excluding {@link PianoLayout.keyGap}. */
+  whiteKeyWidth: number;
+  /**
+   * Space between two white keys. Part of the slot a white key occupies, so it
+   * still belongs to one of the keys for the purpose of hit testing.
+   *
+   * @default 1
+   */
+  keyGap?: number;
+  /**
+   * Width of a black key, as a fraction of {@link PianoLayout.whiteKeyWidth}.
+   *
+   * @default 0.65
+   */
+  blackKeyWidthRatio?: number;
+  /**
+   * Height of a black key, as a fraction of the height of the keyboard.
+   *
+   * @default 0.6
+   */
+  blackKeyHeightRatio?: number;
+}
+/** Width of a black key in pixels. */
+declare function blackKeyWidth(layout: PianoLayout): number;
+/** Width of the whole keyboard in pixels. */
+declare function pianoWidth(layout: PianoLayout): number;
+/**
+ * Offset of the left edge of a key from the left edge of the keyboard, in
+ * pixels.
+ *
+ * Notes outside `noteRange` are placed too, so the value is negative below
+ * `noteRange.first`.
+ */
+declare function notePosition(note: number, layout: PianoLayout): number;
+/**
+ * The note drawn at a point, or null where there is none.
+ *
+ * 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
+ */
+declare function noteAt(x: number, y: number, height: number, layout: PianoLayout): number | null;
+//#endregion
+//#region src/unit.d.ts
+/**
+ * The SI prefixes {@link unitFormat} chooses between.
+ *
+ * Deliberately narrower than the full SI set: yocto through yotta are of no
+ * use to an audio control, and every extra prefix is one more symbol `parse`
+ * has to tell apart from a unit.
+ */
+type SIPrefix = 'p' | 'n' | 'µ' | 'm' | '' | 'k' | 'M' | 'G';
+interface UnitFormatOptions {
+  /**
+   * The prefix the stored value is already in.
+   *
+   * A control that keeps milliseconds in `value` is `{ base: 'm' }` with a
+   * unit of `'s'`: 1500 then displays as `1.5s`, and `parse` gives 1500 back.
+   *
+   * @default ''
+   */
+  base?: SIPrefix;
+  /**
+   * Whether to scale the number and pick a prefix at all.
+   *
+   * Turn it off for anything that is not an SI quantity. dB, %, cents and
+   * semitones do not take prefixes, and `-6dB` read as "-6 deci-B" is wrong
+   * rather than merely unusual.
+   *
+   * @default true
+   */
+  prefixes?: boolean;
+  /**
+   * Digits after the decimal point. The number is left as-is when omitted.
+   */
+  digits?: number;
+  /**
+   * Text placed between the number and the unit.
+   * @default ''
+   */
+  separator?: string;
+}
+/** The `format` / `parse` pair a `NumberInput` takes. */
+interface UnitFormatter {
+  format: (value: number) => string;
+  parse: (text: string) => number;
+}
+/**
+ * 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.
+ *
+ * @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
+ * <NumberInput.Root {...unitFormat('Hz', { digits: 2 })} value={v} onChange={setV}>
  */
-type InputEventOption = ['normalized' | 'raw', number];
+declare function unitFormat(unit: string, options?: UnitFormatOptions): UnitFormatter;
 //#endregion
 //#region src/util.d.ts
-type Operator = '+' | '-' | '*' | '/';
-declare function styleHelper(value: string | number): string;
-declare function styleHelper(value: string | number, op: Operator, influencer?: number): string;
-declare function isEmpty(obj: object): boolean;
 declare function mod(n: number, m: number): number;
 declare function xor(a?: boolean, b?: boolean): boolean;
 //#endregion
-export { type InputEventOption, type NoteKey, type WhiteKey, clamp, dbToGain, decimalPart, degree, gainToDb, integerPart, isBlackKey, isEmpty, isWhiteKey, mapValue, mod, normalizeValue, noteKey, noteKeys, noteName, noteNumber, noteToFrequency, parseNoteName, radian, rawValue, skewWithCenterValue, stepValue, styleHelper, toFixed, whiteKeys, xor };
+export { type InputEventOption, type Modifier, type ModifierMap, type ModifierState, type ModifierValue, type NoteKey, type NoteRange, type PianoLayout, SIGNIFICANT_DIGITS, type SIPrefix, type Scale, type ScaleName, type SelectedInputEvent, type UnitFormatOptions, type UnitFormatter, type ValueRange, type WhiteKey, applyDelta, blackKeyWidth, clamp, curveScale, curveWithCenterValue, dbToGain, decimalPart, degree, exponentialScale, gainToDb, getNoteRangeArray, inScale, integerPart, isBlackKey, isWhiteKey, linearScale, mapModifier, mapValue, mod, normalizeValue, noteAt, noteKey, noteKeys, noteName, noteNumber, notePosition, noteToFrequency, parseNoteName, pianoWidth, radian, rawValue, scaleIntervals, scaleNotes, selectInputEvent, selectModifier, skewScale, skewWithCenterValue, stepValue, symmetricSkewScale, toFixed, toPrecision, unitFormat, whiteKeys, xor };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/math.ts","../src/midi.ts","../src/types.ts","../src/util.ts"],"mappings":";;AAGA;;iBAAgB,KAAA,CAAM,KAAA,UAAe,GAAA,UAAa,GAAA;;;;iBAOlC,cAAA,CACd,QAAA,UACA,GAAA,UACA,GAAA,UACA,IAAA;;;AAJF;iBAcgB,QAAA,CACd,eAAA,UACA,GAAA,UACA,GAAA,UACA,IAAA;AAAA,iBAUc,mBAAA,CACd,WAAA,UACA,GAAA,UACA,GAAA;AAAA,iBAOc,SAAA,CAAU,KAAA,UAAe,IAAA;AAAA,iBASzB,OAAA,CAAQ,CAAA,UAAW,cAAA;AAAA,iBAInB,WAAA,CAAY,CAAA;AAAA,iBAOZ,WAAA,CAAY,CAAA;AAAA,iBAIZ,MAAA,CAAO,MAAA;AAAA,iBAIP,MAAA,CAAO,MAAA;AAAA,iBAIP,QAAA,CACd,KAAA,UACA,KAAA,UACA,KAAA,UACA,MAAA,UACA,MAAA;AAAA,iBAKc,QAAA,CAAS,EAAA;AAAA,iBAIT,QAAA,CAAS,IAAA;;;cC5FZ,SAAA;AAAA,KAED,QAAA,WAAmB,SAAA;AAAA,cAElB,QAAA;AAAA,KAeD,OAAA,WAAkB,QAAA;AAAA,iBAEd,aAAA,CAAc,QAAA;UAKY,QAAA;;;;;ADlB1C;;iBC2BgB,UAAA,CAAW,QAAA;;;;;;;iBAaX,QAAA,CAAS,UAAA,cAAwB,OAAA;AD1BjD;;;AAAA,iBCmCgB,OAAA,CAAQ,UAAA,WAAqB,OAAA;;;;iBAO7B,UAAA,CAAW,IAAA;;;AD5B3B;iBC4CgB,UAAA,CAAW,IAAA;;;;;;;iBAUX,eAAA,CAAgB,IAAA,mBAAuB,MAAA,WAAY,EAAA;;;;ADzFnE;;KEAY,gBAAA;;;KCHP,QAAA;AAAA,iBAEW,WAAA,CAAY,KAAA;AAAA,iBACZ,WAAA,CACd,KAAA,mBACA,EAAA,EAAI,QAAA,EACJ,UAAA;AAAA,iBAyBc,OAAA,CAAQ,GAAA;AAAA,iBAIR,GAAA,CAAI,CAAA,UAAW,CAAA;AAAA,iBAIf,GAAA,CAAI,CAAA,YAAW,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/math.ts","../src/modifiers.ts","../src/scales.ts","../src/midi.ts","../src/piano.ts","../src/unit.ts","../src/util.ts"],"mappings":";;;;iBAGgB,MAAM,eAAe,aAAa;;;;;;;iBAUlC,eAAe,eAAe,aAAa;;;;;;iBAU3C,SAAS,yBAAyB,aAAa;;;;;;;;;;;iBAe/C,UAAU,eAAe;iBAUzB,QAAQ,WAAW;;;;;;cAStB;;;;;;;;;;;;;;;;;;;;;iBAsBG,YAAY,WAAW;iBAUvB,YAAY;iBAOZ,YAAY;iBAIZ,OAAO;iBAIP,OAAO;iBAIP,SACd,eACA,eACA,eACA,gBACA;iBAKc,SAAS;iBAIT,SAAS;;;;;;KCvHb;;;;;;;;KASA;;UAGK;EACf;EACA;EACA;EACA;;;KAIG,2BAA2B;KAEpB,YAAY,UAAU;EAAqB,SAAS;IAAM,QACpE,OAAO,UAAU;;;;;;;;KAUP,cAAc,UAAU,mBAAmB,IAAI,YAAY;UAEtD;EACf,QAAQ;;EAER,UAAU;;;;;;;;iBAsCI,eAAe,UAAU,iBACvC,SAAS,cAAc,IACvB,YAAY;EACT,OAAO;EAAG,UAAU;;;;;;;;;;;;;;;;iBAiCT,YACd,UAAU,iBACV,UAAU,iBACV,SAAS,cAAc,IAAI,KAAK,OAAO,MAAM,IAAI,cAAc;;;;;;;iBAgBjD,iBACd,SAAS,cAAc,mBACvB,YAAY,gBACX;;;;;;;;;;;;;;;;;;UClHc;;EAEf,YAAY,eAAe,aAAa;;EAExC,cAAc,kBAAkB,aAAa;;;;;;;;cAmBlC,aAAa;;;;;;;;;;;;;;;;;iBAqBV,UAAU,eAAe;;;;;iBAsBzB,oBACd,qBACA,aACA;;;;;;;;;;;;cAmBW,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBAqDf,WAAW,gBAAgB;;;;;;;;;;;;;iBAmD3B,mBAAmB,eAAe;;;;;iBAiClC,qBACd,qBACA,aACA;;;;;;;;UAkBe;EACf;EACA;;;;EAIA;;;;;;EAMA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;iBAwBM,WACd,eACA,mBACA,SAAS,cAAc,qBACrB,KAAK,KAAK,MAAM,SAAuB,YACzC,YAAY;;;cCpTD;KAED,mBAAmB;cAElB;KAeD,kBAAkB;iBAQd,cAAc;EAOY,QAAA;EACZ;;;;;;iBAQd,WAAW;;;;;;;iBAeX,SAAS,wBAAwB;;;;iBAUjC,QAAQ,qBAAqB;;;;iBAQ7B,WAAW;;;;iBAiBX,WAAW;;;;;;;iBAUX,gBAAgB,uBAAuB,iBAAY;;;;;;;;;;;;cAiBtD;;;;;;;;;;;;;;;;;;KAsBD,yBAAyB;;;;;;;;;;;;iBAarB,QACd,uBACA,uBACA,MAAM;;;;;;;;;;;;;;;iBAuBQ,WACd,uBACA,MAAM,WACN;;;KCxLU;EACV;EACA;;;;;iBAMc,kBAAkB,WAAW;;;;;;;UAa5B;EACf,WAAW;;EAGX;;;;;;;EAQA;;;;;;EAOA;;;;;;EAOA;;;iBA8Bc,cAAc,QAAQ;;iBA0CtB,WAAW,QAAQ;;;;;;;;iBAYnB,aAAa,cAAc,QAAQ;;;;;;;;;;;;iBAenC,OACd,WACA,WACA,gBACA,QAAQ;;;;;;;;;;KC/IE;UAwBK;;;;;;;;;EASf,OAAO;;;;;;;;;;EAUP;;;;EAIA;;;;;EAKA;;;UAIe;EACf,SAAS;EACT,QAAQ;;;;;;;;;;;;;;;;;;iBAiCM,WACd,cACA,UAAS,oBACR;;;iBCvGa,IAAI,WAAW;iBAIf,IAAI,aAAW"}