@tremolo-ui/functions 0.4.0 → 0.5.0

package/src/index.ts

@@ -9,13 +9,26 @@ export {
   normalizeValue,
   radian,
   rawValue,
-  skewWithCenterValue,
   stepValue,
   toFixed,
 } from './math'
+export {
+  type Scale,
+  type ValueRange,
+  applyDelta,
+  curveScale,
+  curveWithCenterValue,
+  exponentialScale,
+  linearScale,
+  skewScale,
+  skewWithCenterValue,
+  symmetricSkewScale,
+} from './scales'
 export {
   type NoteKey,
+  type ScaleName,
   type WhiteKey,
+  inScale,
   isBlackKey,
   isWhiteKey,
   noteKey,
@@ -24,7 +37,19 @@ export {
   noteNumber,
   noteToFrequency,
   parseNoteName,
+  scaleIntervals,
+  scaleNotes,
   whiteKeys,
 } from './midi'
+export {
+  type NoteRange,
+  type PianoLayout,
+  blackKeyWidth,
+  getNoteRangeArray,
+  noteAt,
+  notePosition,
+  pianoWidth,
+} from './piano'
 export { type InputEventOption } from './types'
+export { type Units, formatValue, parseValue, selectUnit } from './unit'
 export { isEmpty, mod, styleHelper, xor } from './util'

package/src/math.ts

@@ -6,44 +6,24 @@ export function clamp(value: number, min: number, max: 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.
  */
-export function normalizeValue(
-  rawValue: number,
-  min: number,
-  max: number,
-  skew = 1,
-) {
+export function normalizeValue(value: number, min: number, max: number) {
   if (min >= max) throw new RangeError('requirements: min < max')
-  const v = clamp((rawValue - min) / (max - min), 0, 1)
-  return Math.pow(v, skew)
+  return clamp((value - min) / (max - min), 0, 1)
 }
 
 /**
- * Convert normalized values back to raw values.
+ * Convert normalized values back to raw values, spreading the range evenly.
+ *
+ * The inverse of {@link normalizeValue}.
  */
-export function rawValue(
-  normalizedValue: number,
-  min: number,
-  max: number,
-  skew = 1,
-) {
+export function rawValue(normalizedValue: number, min: number, max: number) {
   if (min >= max) throw new RangeError('requirements: min < max')
-  const v =
-    skew == 1
-      ? clamp(normalizedValue, 0, 1)
-      : Math.exp(Math.log(clamp(normalizedValue, 0, 1)) / skew)
-  return min + v * (max - min)
-}
-
-export function skewWithCenterValue(
-  centerValue: number,
-  min: number,
-  max: number,
-) {
-  if (!(min <= centerValue && centerValue <= max))
-    throw new RangeError('requirements: min <= centerValue <= max')
-  return Math.log(0.5) / Math.log((centerValue - min) / (max - min))
+  return min + clamp(normalizedValue, 0, 1) * (max - min)
 }
 
 export function stepValue(value: number, step: number) {

package/src/midi.ts

@@ -94,3 +94,85 @@ export function noteToFrequency(note: number | string, detune = 0, a4 = 440) {
   const n = typeof note == 'string' ? noteNumber(note) : note
   return (a4 / 32) * 2 ** ((n - 9 + detune / 100) / 12)
 }
+
+/**
+ * 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.
+ */
+export const scaleIntervals = {
+  major: [0, 2, 4, 5, 7, 9, 11],
+  naturalMinor: [0, 2, 3, 5, 7, 8, 10],
+  harmonicMinor: [0, 2, 3, 5, 7, 8, 11],
+  melodicMinor: [0, 2, 3, 5, 7, 9, 11],
+
+  ionian: [0, 2, 4, 5, 7, 9, 11],
+  dorian: [0, 2, 3, 5, 7, 9, 10],
+  phrygian: [0, 1, 3, 5, 7, 8, 10],
+  lydian: [0, 2, 4, 6, 7, 9, 11],
+  mixolydian: [0, 2, 4, 5, 7, 9, 10],
+  aeolian: [0, 2, 3, 5, 7, 8, 10],
+  locrian: [0, 1, 3, 5, 6, 8, 10],
+
+  majorPentatonic: [0, 2, 4, 7, 9],
+  minorPentatonic: [0, 3, 5, 7, 10],
+  blues: [0, 3, 5, 6, 7, 10],
+
+  wholeTone: [0, 2, 4, 6, 8, 10],
+  chromatic: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+} as const satisfies Record<string, readonly number[]>
+
+export 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
+ * ```
+ */
+export function inScale(
+  note: number | string,
+  root: number | string,
+  name: ScaleName,
+): boolean {
+  const n = typeof note == 'string' ? noteNumber(note) : note
+  const r = typeof root == 'string' ? noteNumber(root) : root
+  return (scaleIntervals[name] as readonly number[]).includes(mod(n - r, 12))
+}
+
+/**
+ * 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]
+ * ```
+ */
+export function scaleNotes(
+  root: number | string,
+  name: ScaleName,
+  octaves = 1,
+): number[] {
+  const r = typeof root == 'string' ? noteNumber(root) : root
+  const intervals = scaleIntervals[name] as readonly number[]
+  return Array.from({ length: octaves }, (_, octave) =>
+    intervals.map((interval) => r + octave * 12 + interval),
+  ).flat()
+}

package/src/piano.ts

@@ -0,0 +1,163 @@
+import { isBlackKey, isWhiteKey, noteKey, noteKeys, type NoteKey } from './midi'
+
+export type NoteRange = {
+  first: number
+  last: number
+}
+
+/**
+ * `[noteRange.first, noteRange.first + 1, ..., noteRange.last]`
+ */
+export function getNoteRangeArray(noteRange: NoteRange): number[] {
+  return Array.from(
+    { length: noteRange.last - noteRange.first + 1 },
+    (_, i) => i + noteRange.first,
+  )
+}
+
+/**
+ * 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.
+ */
+export 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
+}
+
+const DEFAULT_KEY_GAP = 1
+const DEFAULT_BLACK_KEY_WIDTH_RATIO = 0.65
+const DEFAULT_BLACK_KEY_HEIGHT_RATIO = 0.6
+
+/**
+ * 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.
+ */
+const whiteKeysBefore: Record<NoteKey, number> = {
+  C: 0,
+  'C#': 1,
+  D: 1,
+  'D#': 2,
+  E: 2,
+  F: 3,
+  'F#': 4,
+  G: 4,
+  'G#': 5,
+  A: 5,
+  'A#': 6,
+  B: 6,
+}
+
+/** Width of a black key in pixels. */
+export function blackKeyWidth(layout: PianoLayout): number {
+  return (
+    layout.whiteKeyWidth *
+    (layout.blackKeyWidthRatio ?? DEFAULT_BLACK_KEY_WIDTH_RATIO)
+  )
+}
+
+/** Width of the whole keyboard in pixels. */
+export function pianoWidth(layout: PianoLayout): number {
+  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.
+ *
+ * Notes outside `noteRange` are placed too, so the value is negative below
+ * `noteRange.first`.
+ */
+export function notePosition(note: number, layout: PianoLayout): number {
+  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)
+  // A note whose pitch class comes before the first one belongs to the octave
+  // above the one the division above gives.
+  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
+}
+
+/**
+ * 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
+ */
+export function noteAt(
+  x: number,
+  y: number,
+  height: number,
+  layout: PianoLayout,
+): number | null {
+  if (y < 0 || y >= height) return null
+
+  const notes = getNoteRangeArray(layout.noteRange)
+  const blackHeight =
+    height * (layout.blackKeyHeightRatio ?? DEFAULT_BLACK_KEY_HEIGHT_RATIO)
+
+  if (y < blackHeight) {
+    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
+}

package/src/scales.ts

@@ -0,0 +1,284 @@
+import { clamp, normalizeValue, rawValue, stepValue } from './math'
+
+import type { InputEventOption } from './types'
+
+/**
+ * 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…
+ * ```
+ */
+export 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
+}
+
+function assertRange(min: number, max: number) {
+  if (min >= max) throw new RangeError('requirements: min < max')
+}
+
+/**
+ * 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.
+ */
+export const linearScale: Scale = {
+  normalize: (value, min, max) => normalizeValue(value, min, max),
+  denormalize: (position, min, max) => rawValue(position, min, max),
+}
+
+/**
+ * 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
+ */
+export function skewScale(skew: number): Scale {
+  return {
+    // The two expressions JUCE uses, kept verbatim so the numbers agree with
+    // a NormalisableRange: pow() one way, exp(log()) the other.
+    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,
+      ),
+  }
+}
+
+/**
+ * The skew factor for {@link skewScale} that puts `centerValue` at the middle
+ * of the travel — JUCE's `NormalisableRange::setSkewForCentre`.
+ */
+export function skewWithCenterValue(
+  centerValue: number,
+  min: number,
+  max: number,
+) {
+  if (!(min <= centerValue && centerValue <= max))
+    throw new RangeError('requirements: min <= centerValue <= max')
+  return Math.log(0.5) / Math.log((centerValue - min) / (max - min))
+}
+
+/**
+ * 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.
+ */
+export const exponentialScale: Scale = {
+  normalize: (value, min, max) => {
+    assertExponentialRange(min, max)
+    // The value is clamped before the logarithm, not after: outside the range
+    // the ratio can be negative, and log() would give NaN rather than a
+    // position to clamp.
+    return clamp(
+      Math.log(clamp(value, min, max) / min) / Math.log(max / min),
+      0,
+      1,
+    )
+  },
+  denormalize: (position, min, max) => {
+    assertExponentialRange(min, max)
+    return min * Math.pow(max / min, clamp(position, 0, 1))
+  },
+}
+
+function assertExponentialRange(min: number, max: number) {
+  assertRange(min, max)
+  if (min === 0 || max === 0 || Math.sign(min) !== Math.sign(max)) {
+    throw new RangeError(
+      'exponentialScale: requirements: min and max are non-zero and have the same sign',
+    )
+  }
+}
+
+/**
+ * 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
+ */
+export function curveScale(curve: number): Scale {
+  // The two coefficients blow up as the curve flattens: `a` divides by
+  // 1 - e^curve, which goes to 0.
+  if (Math.abs(curve) < 0.001) return linearScale
+
+  const grow = Math.exp(curve)
+
+  // value(position) = b - a * e^(curve * position), fixed so that
+  // value(0) = min and value(1) = max.
+  const coefficients = (min: number, max: number) => {
+    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)
+      // Clamped before the logarithm: far outside the range `(b - value) / a`
+      // turns negative and log() would give NaN.
+      return clamp(Math.log((b - clamp(value, min, max)) / a) / curve, 0, 1)
+    },
+    denormalize: (position, min, max) => {
+      assertRange(min, max)
+      const { a, b } = coefficients(min, max)
+      return b - a * Math.pow(grow, clamp(position, 0, 1))
+    },
+  }
+}
+
+/**
+ * {@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
+ */
+export function symmetricSkewScale(skew: number): Scale {
+  return {
+    normalize: (value, min, max) => {
+      assertRange(min, max)
+      const proportion = clamp((value - min) / (max - min), 0, 1)
+      if (skew === 1) return proportion
+      const distanceFromMiddle = 2 * proportion - 1
+      return (
+        (1 +
+          Math.pow(Math.abs(distanceFromMiddle), skew) *
+            Math.sign(distanceFromMiddle)) /
+        2
+      )
+    },
+    denormalize: (position, min, max) => {
+      assertRange(min, max)
+      const p = clamp(position, 0, 1)
+      let distanceFromMiddle = 2 * p - 1
+      if (skew !== 1 && distanceFromMiddle !== 0) {
+        distanceFromMiddle =
+          Math.pow(Math.abs(distanceFromMiddle), 1 / skew) *
+          Math.sign(distanceFromMiddle)
+      }
+      return min + ((max - min) / 2) * (1 + distanceFromMiddle)
+    },
+  }
+}
+
+/**
+ * The curve for {@link curveScale} that puts `centerValue` at the middle of
+ * the travel — the counterpart of {@link skewWithCenterValue}.
+ */
+export function curveWithCenterValue(
+  centerValue: number,
+  min: number,
+  max: number,
+) {
+  assertRange(min, max)
+  if (!(min < centerValue && centerValue < max)) {
+    throw new RangeError('requirements: min < centerValue < max')
+  }
+  // value(0.5) - min = range / (1 + e^(curve / 2))
+  const proportion = (centerValue - min) / (max - min)
+  return 2 * Math.log(1 / proportion - 1)
+}
+
+/**
+ * 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.
+ */
+export 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`.
+ *
+ * @example
+ * // ArrowDown on a slider whose keyboard option is ['raw', 1]
+ * applyDelta(value, -1, keyboard, { min, max, step, scale })
+ */
+export function applyDelta(
+  value: number,
+  direction: number,
+  [mode, amount]: InputEventOption,
+  { min, max, step, scale = linearScale }: ValueRange,
+): number {
+  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)
+}

package/src/unit.ts

@@ -0,0 +1,73 @@
+/**
+ * Units a value can be displayed in, as `[symbol, scale]` pairs ordered from
+ * the smallest scale up. A value is shown in the largest unit that does not
+ * exceed it.
+ *
+ * @example
+ * [['Hz', 1], ['kHz', 1000]]
+ * [['ms', 1], ['s', 1000]]
+ */
+export type Units = [string, number][]
+
+/**
+ * Pick the unit a value is displayed in: the largest one whose scale does not
+ * exceed the magnitude of the value.
+ */
+export function selectUnit(units: Units, value: number): [string, number] {
+  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.
+ *
+ * @example
+ * formatValue(1234, [['Hz', 1], ['kHz', 1000]], 2) // '1.23kHz'
+ * formatValue(1.5, 'Hz')                           // '1.5Hz'
+ */
+export function formatValue(
+  value: number,
+  units?: string | Units,
+  digit?: number,
+): string {
+  const fixed = (v: number) =>
+    digit != undefined ? 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.
+ *
+ * @example
+ * parseValue('1.23kHz', [['Hz', 1], ['kHz', 1000]]) // 1230
+ * parseValue('4abc')                                // 4
+ */
+export function parseValue(text: string, units?: string | Units): number {
+  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
+  }
+
+  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)
+}