@react-synth/synth 0.0.6-alpha

package/dist/index.js

@@ -0,0 +1,1701 @@
+import { jsx } from "react/jsx-runtime";
+import React, { createContext, useRef, useEffect, useMemo, useContext, useId, Children, isValidElement, cloneElement } from "react";
+import { AudioContext } from "node-web-audio-api";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+let schedulerInstance;
+let audioContextInstance;
+class Scheduler {
+  context;
+  _bpm;
+  startTime;
+  events = /* @__PURE__ */ new Map();
+  timerID = null;
+  running = false;
+  lookahead = 0.1;
+  scheduleInterval = 25;
+  /** Grace period before actually removing a loop - allows React HMR to re-add it */
+  removalGracePeriod = 100;
+  constructor(bpm) {
+    if (!audioContextInstance) {
+      audioContextInstance = new AudioContext();
+    }
+    this.context = audioContextInstance;
+    this._bpm = bpm;
+    this.startTime = this.context.currentTime;
+  }
+  // --- Public API ---
+  get audioContext() {
+    return this.context;
+  }
+  get bpm() {
+    return this._bpm;
+  }
+  set bpm(value) {
+    this._bpm = value;
+  }
+  start() {
+    if (this.running) return;
+    this.startTime = this.context.currentTime;
+    this.running = true;
+    for (const event of this.events.values()) {
+      if (event.intervalBeats > 0) {
+        event.nextBeatTime = 0;
+        event.active = true;
+      }
+    }
+    this.timerID = setInterval(() => this.schedule(), this.scheduleInterval);
+  }
+  stop() {
+    if (this.timerID) {
+      clearInterval(this.timerID);
+      this.timerID = null;
+    }
+    this.running = false;
+    console.debug("[scheduler] stopped");
+  }
+  clear() {
+    this.events.clear();
+  }
+  addLoop(id, intervalBeats, callback, startBeat) {
+    const existing = this.events.get(id);
+    if (existing && existing.intervalBeats === intervalBeats) {
+      existing.callback = callback;
+      existing.active = true;
+      existing.pendingRemoval = void 0;
+      return;
+    }
+    const currentBeat = this.getCurrentBeat();
+    let nextBeat;
+    if (startBeat !== void 0) {
+      nextBeat = startBeat;
+    } else {
+      nextBeat = Math.ceil(currentBeat / intervalBeats) * intervalBeats;
+      if (nextBeat <= currentBeat) {
+        nextBeat += intervalBeats;
+      }
+    }
+    this.events.delete(id);
+    this.events.set(id, {
+      id,
+      nextBeatTime: nextBeat,
+      intervalBeats,
+      callback,
+      active: true
+    });
+    console.debug(
+      `[scheduler] loop "${id}" added, interval=${intervalBeats} beats, start=${nextBeat.toFixed(2)}`
+    );
+  }
+  remove(id) {
+    const event = this.events.get(id);
+    if (event) {
+      event.pendingRemoval = Date.now();
+    }
+  }
+  beatsToSeconds(beats) {
+    return beats * 60 / this._bpm;
+  }
+  // --- Private ---
+  secondsToBeats(seconds) {
+    return seconds * this._bpm / 60;
+  }
+  getCurrentBeat() {
+    const elapsed = this.context.currentTime - this.startTime;
+    return this.secondsToBeats(elapsed);
+  }
+  beatToAudioTime(beatTime) {
+    return this.startTime + this.beatsToSeconds(beatTime);
+  }
+  schedule() {
+    const currentAudioTime = this.context.currentTime;
+    const currentBeat = this.getCurrentBeat();
+    const scheduleUntilBeat = currentBeat + this.secondsToBeats(this.lookahead);
+    const now = Date.now();
+    for (const event of this.events.values()) {
+      if (event.pendingRemoval !== void 0) continue;
+      if (!event.active) continue;
+      while (event.nextBeatTime < scheduleUntilBeat) {
+        const audioTime = this.beatToAudioTime(event.nextBeatTime);
+        if (audioTime >= currentAudioTime) {
+          event.callback(audioTime, event.nextBeatTime);
+        }
+        if (event.intervalBeats > 0) {
+          event.nextBeatTime += event.intervalBeats;
+        } else {
+          event.active = false;
+          break;
+        }
+      }
+    }
+    for (const [id, event] of this.events) {
+      if (!event.active && event.intervalBeats === 0) {
+        this.events.delete(id);
+      } else if (event.pendingRemoval !== void 0 && now - event.pendingRemoval > this.removalGracePeriod) {
+        this.events.delete(id);
+        console.debug(`[scheduler] loop "${id}" removed`);
+      }
+    }
+  }
+}
+function getScheduler(bpm) {
+  if (!schedulerInstance) {
+    schedulerInstance = new Scheduler(bpm);
+  } else {
+    schedulerInstance.bpm = bpm;
+  }
+  return schedulerInstance;
+}
+function resetScheduler(bpm) {
+  if (schedulerInstance) {
+    schedulerInstance.stop();
+    schedulerInstance.clear();
+  }
+  schedulerInstance = new Scheduler(bpm);
+  return schedulerInstance;
+}
+const ScheduleNoteContext = createContext(null);
+const TrackContext = createContext(null);
+function Track({ bpm, children }) {
+  const scheduler = useRef(getScheduler(bpm));
+  const audioContext = scheduler.current.audioContext;
+  useEffect(() => {
+    scheduler.current.start();
+  }, [scheduler]);
+  const scheduleContextValue = useMemo(
+    () => ({
+      scheduleNote: (_id, callback) => {
+        const now = audioContext.currentTime + 5e-3;
+        callback(now, 0);
+      },
+      unscheduleNote: () => {
+      }
+    }),
+    [audioContext]
+  );
+  return /* @__PURE__ */ jsx(
+    TrackContext.Provider,
+    {
+      value: {
+        audioContext,
+        scheduler: scheduler.current
+      },
+      children: /* @__PURE__ */ jsx(ScheduleNoteContext.Provider, { value: scheduleContextValue, children })
+    }
+  );
+}
+function useTrack() {
+  const ctx = useContext(TrackContext);
+  if (!ctx) {
+    throw new Error("useTrack must be used inside a <Track> component");
+  }
+  return ctx;
+}
+function useScheduleNote() {
+  const ctx = useContext(ScheduleNoteContext);
+  if (!ctx) {
+    throw new Error("useScheduleNote must be used inside a <Track> component");
+  }
+  return ctx;
+}
+function Loop({
+  id,
+  interval: interval2,
+  children
+}) {
+  const { scheduler } = useTrack();
+  const callbacksRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    const loopId = id;
+    const callbacks = callbacksRef.current;
+    const runAllCallbacks = (audioTime, beatTime) => {
+      for (const callback of callbacks.values()) {
+        callback(audioTime, beatTime);
+      }
+    };
+    scheduler.addLoop(loopId, interval2, runAllCallbacks);
+    return () => {
+      scheduler.remove(loopId);
+    };
+  }, [id, interval2, scheduler]);
+  const scheduleContextValue = useMemo(
+    () => ({
+      scheduleNote: (noteId, callback) => {
+        callbacksRef.current.set(noteId, callback);
+      },
+      unscheduleNote: (noteId) => {
+        callbacksRef.current.delete(noteId);
+      }
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsx(ScheduleNoteContext.Provider, { value: scheduleContextValue, children });
+}
+const ADSR_DEFAULTS = {
+  attack: 0,
+  attack_level: 1,
+  decay: 0,
+  sustain: 0,
+  sustain_level: 1,
+  release: 1
+};
+function applyADSREnvelope(gainNode, audioTime, props, amp, beatsToSeconds) {
+  const attack = props.attack ?? ADSR_DEFAULTS.attack;
+  const attack_level = props.attack_level ?? ADSR_DEFAULTS.attack_level;
+  const decay = props.decay ?? ADSR_DEFAULTS.decay;
+  const sustain = props.sustain ?? ADSR_DEFAULTS.sustain;
+  const sustain_level = props.sustain_level ?? ADSR_DEFAULTS.sustain_level;
+  const release = props.release ?? ADSR_DEFAULTS.release;
+  const decay_level = props.decay_level ?? sustain_level;
+  const attackSec = beatsToSeconds(attack);
+  const decaySec = beatsToSeconds(decay);
+  const sustainSec = beatsToSeconds(sustain);
+  const releaseSec = beatsToSeconds(release);
+  const attackAmp = attack_level * amp;
+  const decayAmp = decay_level * amp;
+  const sustainAmp = sustain_level * amp;
+  const attackEnd = audioTime + attackSec;
+  const decayEnd = attackEnd + decaySec;
+  const sustainEnd = decayEnd + sustainSec;
+  const releaseEnd = sustainEnd + releaseSec;
+  gainNode.gain.setValueAtTime(1e-3, audioTime);
+  if (attackSec > 0) {
+    gainNode.gain.linearRampToValueAtTime(attackAmp, attackEnd);
+  } else {
+    gainNode.gain.setValueAtTime(attackAmp, audioTime);
+  }
+  if (decaySec > 0) {
+    gainNode.gain.linearRampToValueAtTime(decayAmp, decayEnd);
+  } else {
+    gainNode.gain.setValueAtTime(decayAmp, attackEnd);
+  }
+  if (sustainSec > 0) {
+    gainNode.gain.linearRampToValueAtTime(sustainAmp, decayEnd + 1e-3);
+    gainNode.gain.setValueAtTime(sustainAmp, sustainEnd);
+  } else {
+    gainNode.gain.setValueAtTime(sustainAmp, decayEnd);
+  }
+  gainNode.gain.exponentialRampToValueAtTime(1e-3, releaseEnd);
+  return releaseEnd;
+}
+function isNamedPitch(src) {
+  return src !== null && typeof src === "object" && "name" in src && typeof src.name === "string" ? true : false;
+}
+function isPitch(pitch2) {
+  return pitch2 !== null && typeof pitch2 === "object" && "step" in pitch2 && typeof pitch2.step === "number" && "alt" in pitch2 && typeof pitch2.alt === "number" && !isNaN(pitch2.step) && !isNaN(pitch2.alt) ? true : false;
+}
+var FIFTHS = [0, 2, 4, -1, 1, 3, 5];
+var STEPS_TO_OCTS = FIFTHS.map(
+  (fifths) => Math.floor(fifths * 7 / 12)
+);
+function coordinates(pitch2) {
+  const { step, alt, oct, dir = 1 } = pitch2;
+  const f = FIFTHS[step] + 7 * alt;
+  if (oct === void 0) {
+    return [dir * f];
+  }
+  const o = oct - STEPS_TO_OCTS[step] - 4 * alt;
+  return [dir * f, dir * o];
+}
+var FIFTHS_TO_STEPS = [3, 0, 4, 1, 5, 2, 6];
+function pitch(coord) {
+  const [f, o, dir] = coord;
+  const step = FIFTHS_TO_STEPS[unaltered(f)];
+  const alt = Math.floor((f + 1) / 7);
+  if (o === void 0) {
+    return { step, alt, dir };
+  }
+  const oct = o + 4 * alt + STEPS_TO_OCTS[step];
+  return { step, alt, oct, dir };
+}
+function unaltered(f) {
+  const i = (f + 1) % 7;
+  return i < 0 ? 7 + i : i;
+}
+var fillStr$1 = (s, n) => Array(Math.abs(n) + 1).join(s);
+var NoInterval = Object.freeze({
+  empty: true,
+  name: "",
+  num: NaN,
+  q: "",
+  type: "",
+  step: NaN,
+  alt: NaN,
+  dir: NaN,
+  simple: NaN,
+  semitones: NaN,
+  chroma: NaN,
+  coord: [],
+  oct: NaN
+});
+var INTERVAL_TONAL_REGEX = "([-+]?\\d+)(d{1,4}|m|M|P|A{1,4})";
+var INTERVAL_SHORTHAND_REGEX = "(AA|A|P|M|m|d|dd)([-+]?\\d+)";
+var REGEX$2 = new RegExp(
+  "^" + INTERVAL_TONAL_REGEX + "|" + INTERVAL_SHORTHAND_REGEX + "$"
+);
+function tokenizeInterval(str) {
+  const m = REGEX$2.exec(`${str}`);
+  if (m === null) {
+    return ["", ""];
+  }
+  return m[1] ? [m[1], m[2]] : [m[4], m[3]];
+}
+var cache$2 = {};
+function interval(src) {
+  return typeof src === "string" ? cache$2[src] || (cache$2[src] = parse$1(src)) : isPitch(src) ? interval(pitchName$1(src)) : isNamedPitch(src) ? interval(src.name) : NoInterval;
+}
+var SIZES = [0, 2, 4, 5, 7, 9, 11];
+var TYPES = "PMMPPMM";
+function parse$1(str) {
+  const tokens = tokenizeInterval(str);
+  if (tokens[0] === "") {
+    return NoInterval;
+  }
+  const num = +tokens[0];
+  const q = tokens[1];
+  const step = (Math.abs(num) - 1) % 7;
+  const t = TYPES[step];
+  if (t === "M" && q === "P") {
+    return NoInterval;
+  }
+  const type = t === "M" ? "majorable" : "perfectable";
+  const name = "" + num + q;
+  const dir = num < 0 ? -1 : 1;
+  const simple = num === 8 || num === -8 ? num : dir * (step + 1);
+  const alt = qToAlt(type, q);
+  const oct = Math.floor((Math.abs(num) - 1) / 7);
+  const semitones = dir * (SIZES[step] + alt + 12 * oct);
+  const chroma = (dir * (SIZES[step] + alt) % 12 + 12) % 12;
+  const coord = coordinates({ step, alt, oct, dir });
+  return {
+    empty: false,
+    name,
+    num,
+    q,
+    step,
+    alt,
+    dir,
+    type,
+    simple,
+    semitones,
+    chroma,
+    coord,
+    oct
+  };
+}
+function coordToInterval(coord, forceDescending) {
+  const [f, o = 0] = coord;
+  const isDescending = f * 7 + o * 12 < 0;
+  const ivl = forceDescending || isDescending ? [-f, -o, -1] : [f, o, 1];
+  return interval(pitch(ivl));
+}
+function qToAlt(type, q) {
+  return q === "M" && type === "majorable" || q === "P" && type === "perfectable" ? 0 : q === "m" && type === "majorable" ? -1 : /^A+$/.test(q) ? q.length : /^d+$/.test(q) ? -1 * (type === "perfectable" ? q.length : q.length + 1) : 0;
+}
+function pitchName$1(props) {
+  const { step, alt, oct = 0, dir } = props;
+  if (!dir) {
+    return "";
+  }
+  const calcNum = step + 1 + 7 * oct;
+  const num = calcNum === 0 ? step + 1 : calcNum;
+  const d = dir < 0 ? "-" : "";
+  const type = TYPES[step] === "M" ? "majorable" : "perfectable";
+  const name = d + num + altToQ(type, alt);
+  return name;
+}
+function altToQ(type, alt) {
+  if (alt === 0) {
+    return type === "majorable" ? "M" : "P";
+  } else if (alt === -1 && type === "majorable") {
+    return "m";
+  } else if (alt > 0) {
+    return fillStr$1("A", alt);
+  } else {
+    return fillStr$1("d", type === "perfectable" ? alt : alt + 1);
+  }
+}
+var fillStr = (s, n) => Array(Math.abs(n) + 1).join(s);
+var NoNote = Object.freeze({
+  empty: true,
+  name: "",
+  letter: "",
+  acc: "",
+  pc: "",
+  step: NaN,
+  alt: NaN,
+  chroma: NaN,
+  height: NaN,
+  coord: [],
+  midi: null,
+  freq: null
+});
+var cache$1 = /* @__PURE__ */ new Map();
+var stepToLetter = (step) => "CDEFGAB".charAt(step);
+var altToAcc = (alt) => alt < 0 ? fillStr("b", -alt) : fillStr("#", alt);
+var accToAlt = (acc) => acc[0] === "b" ? -acc.length : acc.length;
+function note(src) {
+  const stringSrc = JSON.stringify(src);
+  const cached = cache$1.get(stringSrc);
+  if (cached) {
+    return cached;
+  }
+  const value = typeof src === "string" ? parse(src) : isPitch(src) ? note(pitchName(src)) : isNamedPitch(src) ? note(src.name) : NoNote;
+  cache$1.set(stringSrc, value);
+  return value;
+}
+var REGEX$1 = /^([a-gA-G]?)(#{1,}|b{1,}|x{1,}|)(-?\d*)\s*(.*)$/;
+function tokenizeNote(str) {
+  const m = REGEX$1.exec(str);
+  return m ? [m[1].toUpperCase(), m[2].replace(/x/g, "##"), m[3], m[4]] : ["", "", "", ""];
+}
+function coordToNote(noteCoord) {
+  return note(pitch(noteCoord));
+}
+var mod = (n, m) => (n % m + m) % m;
+var SEMI = [0, 2, 4, 5, 7, 9, 11];
+function parse(noteName) {
+  const tokens = tokenizeNote(noteName);
+  if (tokens[0] === "" || tokens[3] !== "") {
+    return NoNote;
+  }
+  const letter = tokens[0];
+  const acc = tokens[1];
+  const octStr = tokens[2];
+  const step = (letter.charCodeAt(0) + 3) % 7;
+  const alt = accToAlt(acc);
+  const oct = octStr.length ? +octStr : void 0;
+  const coord = coordinates({ step, alt, oct });
+  const name = letter + acc + octStr;
+  const pc = letter + acc;
+  const chroma = (SEMI[step] + alt + 120) % 12;
+  const height = oct === void 0 ? mod(SEMI[step] + alt, 12) - 12 * 99 : SEMI[step] + alt + 12 * (oct + 1);
+  const midi = height >= 0 && height <= 127 ? height : null;
+  const freq2 = oct === void 0 ? null : Math.pow(2, (height - 69) / 12) * 440;
+  return {
+    empty: false,
+    acc,
+    alt,
+    chroma,
+    coord,
+    freq: freq2,
+    height,
+    letter,
+    midi,
+    name,
+    oct,
+    pc,
+    step
+  };
+}
+function pitchName(props) {
+  const { step, alt, oct } = props;
+  const letter = stepToLetter(step);
+  if (!letter) {
+    return "";
+  }
+  const pc = letter + altToAcc(alt);
+  return oct || oct === 0 ? pc + oct : pc;
+}
+function transpose(noteName, intervalName) {
+  const note$1 = note(noteName);
+  const intervalCoord = Array.isArray(intervalName) ? intervalName : interval(intervalName).coord;
+  if (note$1.empty || !intervalCoord || intervalCoord.length < 2) {
+    return "";
+  }
+  const noteCoord = note$1.coord;
+  const tr = noteCoord.length === 1 ? [noteCoord[0] + intervalCoord[0]] : [noteCoord[0] + intervalCoord[0], noteCoord[1] + intervalCoord[1]];
+  return coordToNote(tr).name;
+}
+function distance(fromNote, toNote) {
+  const from = note(fromNote);
+  const to = note(toNote);
+  if (from.empty || to.empty) {
+    return "";
+  }
+  const fcoord = from.coord;
+  const tcoord = to.coord;
+  const fifths = tcoord[0] - fcoord[0];
+  const octs = fcoord.length === 2 && tcoord.length === 2 ? tcoord[1] - fcoord[1] : -Math.floor(fifths * 7 / 12);
+  const forceDescending = to.height === from.height && to.midi !== null && from.oct === to.oct && from.step > to.step;
+  return coordToInterval([fifths, octs], forceDescending).name;
+}
+function rotate(times, arr) {
+  const len = arr.length;
+  const n = (times % len + len) % len;
+  return arr.slice(n, len).concat(arr.slice(0, n));
+}
+var EmptyPcset = {
+  empty: true,
+  name: "",
+  setNum: 0,
+  chroma: "000000000000",
+  normalized: "000000000000",
+  intervals: []
+};
+var setNumToChroma = (num2) => Number(num2).toString(2).padStart(12, "0");
+var chromaToNumber = (chroma2) => parseInt(chroma2, 2);
+var REGEX = /^[01]{12}$/;
+function isChroma(set) {
+  return REGEX.test(set);
+}
+var isPcsetNum = (set) => typeof set === "number" && set >= 0 && set <= 4095;
+var isPcset = (set) => set && isChroma(set.chroma);
+var cache = { [EmptyPcset.chroma]: EmptyPcset };
+function get$5(src) {
+  const chroma2 = isChroma(src) ? src : isPcsetNum(src) ? setNumToChroma(src) : Array.isArray(src) ? listToChroma(src) : isPcset(src) ? src.chroma : EmptyPcset.chroma;
+  return cache[chroma2] = cache[chroma2] || chromaToPcset(chroma2);
+}
+var IVLS = [
+  "1P",
+  "2m",
+  "2M",
+  "3m",
+  "3M",
+  "4P",
+  "5d",
+  "5P",
+  "6m",
+  "6M",
+  "7m",
+  "7M"
+];
+function chromaToIntervals(chroma2) {
+  const intervals2 = [];
+  for (let i = 0; i < 12; i++) {
+    if (chroma2.charAt(i) === "1") intervals2.push(IVLS[i]);
+  }
+  return intervals2;
+}
+function chromaRotations(chroma2) {
+  const binary = chroma2.split("");
+  return binary.map((_, i) => rotate(i, binary).join(""));
+}
+function chromaToPcset(chroma2) {
+  const setNum = chromaToNumber(chroma2);
+  const normalizedNum = chromaRotations(chroma2).map(chromaToNumber).filter((n) => n >= 2048).sort()[0];
+  const normalized = setNumToChroma(normalizedNum);
+  const intervals2 = chromaToIntervals(chroma2);
+  return {
+    empty: false,
+    name: "",
+    setNum,
+    chroma: chroma2,
+    normalized,
+    intervals: intervals2
+  };
+}
+function listToChroma(set) {
+  if (set.length === 0) {
+    return EmptyPcset.chroma;
+  }
+  let pitch2;
+  const binary = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  for (let i = 0; i < set.length; i++) {
+    pitch2 = note(set[i]);
+    if (pitch2.empty) pitch2 = interval(set[i]);
+    if (!pitch2.empty) binary[pitch2.chroma] = 1;
+  }
+  return binary.join("");
+}
+var CHORDS = [
+  // ==Major==
+  ["1P 3M 5P", "major", "M ^  maj"],
+  ["1P 3M 5P 7M", "major seventh", "maj7 Δ ma7 M7 Maj7 ^7"],
+  ["1P 3M 5P 7M 9M", "major ninth", "maj9 Δ9 ^9"],
+  ["1P 3M 5P 7M 9M 13M", "major thirteenth", "maj13 Maj13 ^13"],
+  ["1P 3M 5P 6M", "sixth", "6 add6 add13 M6"],
+  ["1P 3M 5P 6M 9M", "sixth added ninth", "6add9 6/9 69 M69"],
+  ["1P 3M 6m 7M", "major seventh flat sixth", "M7b6 ^7b6"],
+  [
+    "1P 3M 5P 7M 11A",
+    "major seventh sharp eleventh",
+    "maj#4 Δ#4 Δ#11 M7#11 ^7#11 maj7#11"
+  ],
+  // ==Minor==
+  // '''Normal'''
+  ["1P 3m 5P", "minor", "m min -"],
+  ["1P 3m 5P 7m", "minor seventh", "m7 min7 mi7 -7"],
+  [
+    "1P 3m 5P 7M",
+    "minor/major seventh",
+    "m/ma7 m/maj7 mM7 mMaj7 m/M7 -Δ7 mΔ -^7 -maj7"
+  ],
+  ["1P 3m 5P 6M", "minor sixth", "m6 -6"],
+  ["1P 3m 5P 7m 9M", "minor ninth", "m9 -9"],
+  ["1P 3m 5P 7M 9M", "minor/major ninth", "mM9 mMaj9 -^9"],
+  ["1P 3m 5P 7m 9M 11P", "minor eleventh", "m11 -11"],
+  ["1P 3m 5P 7m 9M 13M", "minor thirteenth", "m13 -13"],
+  // '''Diminished'''
+  ["1P 3m 5d", "diminished", "dim ° o"],
+  ["1P 3m 5d 7d", "diminished seventh", "dim7 °7 o7"],
+  ["1P 3m 5d 7m", "half-diminished", "m7b5 ø -7b5 h7 h"],
+  // ==Dominant/Seventh==
+  // '''Normal'''
+  ["1P 3M 5P 7m", "dominant seventh", "7 dom"],
+  ["1P 3M 5P 7m 9M", "dominant ninth", "9"],
+  ["1P 3M 5P 7m 9M 13M", "dominant thirteenth", "13"],
+  ["1P 3M 5P 7m 11A", "lydian dominant seventh", "7#11 7#4"],
+  // '''Altered'''
+  ["1P 3M 5P 7m 9m", "dominant flat ninth", "7b9"],
+  ["1P 3M 5P 7m 9A", "dominant sharp ninth", "7#9"],
+  ["1P 3M 7m 9m", "altered", "alt7"],
+  // '''Suspended'''
+  ["1P 4P 5P", "suspended fourth", "sus4 sus"],
+  ["1P 2M 5P", "suspended second", "sus2"],
+  ["1P 4P 5P 7m", "suspended fourth seventh", "7sus4 7sus"],
+  ["1P 5P 7m 9M 11P", "eleventh", "11"],
+  [
+    "1P 4P 5P 7m 9m",
+    "suspended fourth flat ninth",
+    "b9sus phryg 7b9sus 7b9sus4"
+  ],
+  // ==Other==
+  ["1P 5P", "fifth", "5"],
+  ["1P 3M 5A", "augmented", "aug + +5 ^#5"],
+  ["1P 3m 5A", "minor augmented", "m#5 -#5 m+"],
+  ["1P 3M 5A 7M", "augmented seventh", "maj7#5 maj7+5 +maj7 ^7#5"],
+  [
+    "1P 3M 5P 7M 9M 11A",
+    "major sharp eleventh (lydian)",
+    "maj9#11 Δ9#11 ^9#11"
+  ],
+  // ==Legacy==
+  ["1P 2M 4P 5P", "", "sus24 sus4add9"],
+  ["1P 3M 5A 7M 9M", "", "maj9#5 Maj9#5"],
+  ["1P 3M 5A 7m", "", "7#5 +7 7+ 7aug aug7"],
+  ["1P 3M 5A 7m 9A", "", "7#5#9 7#9#5 7alt"],
+  ["1P 3M 5A 7m 9M", "", "9#5 9+"],
+  ["1P 3M 5A 7m 9M 11A", "", "9#5#11"],
+  ["1P 3M 5A 7m 9m", "", "7#5b9 7b9#5"],
+  ["1P 3M 5A 7m 9m 11A", "", "7#5b9#11"],
+  ["1P 3M 5A 9A", "", "+add#9"],
+  ["1P 3M 5A 9M", "", "M#5add9 +add9"],
+  ["1P 3M 5P 6M 11A", "", "M6#11 M6b5 6#11 6b5"],
+  ["1P 3M 5P 6M 7M 9M", "", "M7add13"],
+  ["1P 3M 5P 6M 9M 11A", "", "69#11"],
+  ["1P 3m 5P 6M 9M", "", "m69 -69"],
+  ["1P 3M 5P 6m 7m", "", "7b6"],
+  ["1P 3M 5P 7M 9A 11A", "", "maj7#9#11"],
+  ["1P 3M 5P 7M 9M 11A 13M", "", "M13#11 maj13#11 M13+4 M13#4"],
+  ["1P 3M 5P 7M 9m", "", "M7b9"],
+  ["1P 3M 5P 7m 11A 13m", "", "7#11b13 7b5b13"],
+  ["1P 3M 5P 7m 13M", "", "7add6 67 7add13"],
+  ["1P 3M 5P 7m 9A 11A", "", "7#9#11 7b5#9 7#9b5"],
+  ["1P 3M 5P 7m 9A 11A 13M", "", "13#9#11"],
+  ["1P 3M 5P 7m 9A 11A 13m", "", "7#9#11b13"],
+  ["1P 3M 5P 7m 9A 13M", "", "13#9"],
+  ["1P 3M 5P 7m 9A 13m", "", "7#9b13"],
+  ["1P 3M 5P 7m 9M 11A", "", "9#11 9+4 9#4"],
+  ["1P 3M 5P 7m 9M 11A 13M", "", "13#11 13+4 13#4"],
+  ["1P 3M 5P 7m 9M 11A 13m", "", "9#11b13 9b5b13"],
+  ["1P 3M 5P 7m 9m 11A", "", "7b9#11 7b5b9 7b9b5"],
+  ["1P 3M 5P 7m 9m 11A 13M", "", "13b9#11"],
+  ["1P 3M 5P 7m 9m 11A 13m", "", "7b9b13#11 7b9#11b13 7b5b9b13"],
+  ["1P 3M 5P 7m 9m 13M", "", "13b9"],
+  ["1P 3M 5P 7m 9m 13m", "", "7b9b13"],
+  ["1P 3M 5P 7m 9m 9A", "", "7b9#9"],
+  ["1P 3M 5P 9M", "", "Madd9 2 add9 add2"],
+  ["1P 3M 5P 9m", "", "Maddb9"],
+  ["1P 3M 5d", "", "Mb5"],
+  ["1P 3M 5d 6M 7m 9M", "", "13b5"],
+  ["1P 3M 5d 7M", "", "M7b5"],
+  ["1P 3M 5d 7M 9M", "", "M9b5"],
+  ["1P 3M 5d 7m", "", "7b5"],
+  ["1P 3M 5d 7m 9M", "", "9b5"],
+  ["1P 3M 7m", "", "7no5"],
+  ["1P 3M 7m 13m", "", "7b13"],
+  ["1P 3M 7m 9M", "", "9no5"],
+  ["1P 3M 7m 9M 13M", "", "13no5"],
+  ["1P 3M 7m 9M 13m", "", "9b13"],
+  ["1P 3m 4P 5P", "", "madd4"],
+  ["1P 3m 5P 6m 7M", "", "mMaj7b6"],
+  ["1P 3m 5P 6m 7M 9M", "", "mMaj9b6"],
+  ["1P 3m 5P 7m 11P", "", "m7add11 m7add4"],
+  ["1P 3m 5P 9M", "", "madd9"],
+  ["1P 3m 5d 6M 7M", "", "o7M7"],
+  ["1P 3m 5d 7M", "", "oM7"],
+  ["1P 3m 6m 7M", "", "mb6M7"],
+  ["1P 3m 6m 7m", "", "m7#5"],
+  ["1P 3m 6m 7m 9M", "", "m9#5"],
+  ["1P 3m 5A 7m 9M 11P", "", "m11A"],
+  ["1P 3m 6m 9m", "", "mb6b9"],
+  ["1P 2M 3m 5d 7m", "", "m9b5"],
+  ["1P 4P 5A 7M", "", "M7#5sus4"],
+  ["1P 4P 5A 7M 9M", "", "M9#5sus4"],
+  ["1P 4P 5A 7m", "", "7#5sus4"],
+  ["1P 4P 5P 7M", "", "M7sus4"],
+  ["1P 4P 5P 7M 9M", "", "M9sus4"],
+  ["1P 4P 5P 7m 9M", "", "9sus4 9sus"],
+  ["1P 4P 5P 7m 9M 13M", "", "13sus4 13sus"],
+  ["1P 4P 5P 7m 9m 13m", "", "7sus4b9b13 7b9b13sus4"],
+  ["1P 4P 7m 10m", "", "4 quartal"],
+  ["1P 5P 7m 9m 11P", "", "11b9"]
+];
+var data_default$2 = CHORDS;
+var NoChordType = {
+  ...EmptyPcset,
+  name: "",
+  quality: "Unknown",
+  intervals: [],
+  aliases: []
+};
+var dictionary = [];
+var index$2 = {};
+function get$4(type) {
+  return index$2[type] || NoChordType;
+}
+function add$2(intervals, aliases, fullName) {
+  const quality = getQuality(intervals);
+  const chord = {
+    ...get$5(intervals),
+    name: fullName || "",
+    quality,
+    intervals,
+    aliases
+  };
+  dictionary.push(chord);
+  if (chord.name) {
+    index$2[chord.name] = chord;
+  }
+  index$2[chord.setNum] = chord;
+  index$2[chord.chroma] = chord;
+  chord.aliases.forEach((alias) => addAlias$1(chord, alias));
+}
+function addAlias$1(chord, alias) {
+  index$2[alias] = chord;
+}
+function getQuality(intervals) {
+  const has = (interval2) => intervals.indexOf(interval2) !== -1;
+  return has("5A") ? "Augmented" : has("3M") ? "Major" : has("5d") ? "Diminished" : has("3m") ? "Minor" : "Unknown";
+}
+data_default$2.forEach(
+  ([ivls, fullName, names2]) => add$2(ivls.split(" "), names2.split(" "), fullName)
+);
+dictionary.sort((a, b) => a.setNum - b.setNum);
+var subtract = combinator((a, b) => [a[0] - b[0], a[1] - b[1]]);
+function combinator(fn) {
+  return (a, b) => {
+    const coordA = interval(a).coord;
+    const coordB = interval(b).coord;
+    if (coordA && coordB) {
+      const coord = fn(coordA, coordB);
+      return coordToInterval(coord).name;
+    }
+  };
+}
+var SCALES = [
+  // Basic scales
+  ["1P 2M 3M 5P 6M", "major pentatonic", "pentatonic"],
+  ["1P 2M 3M 4P 5P 6M 7M", "major", "ionian"],
+  ["1P 2M 3m 4P 5P 6m 7m", "minor", "aeolian"],
+  // Jazz common scales
+  ["1P 2M 3m 3M 5P 6M", "major blues"],
+  ["1P 3m 4P 5d 5P 7m", "minor blues", "blues"],
+  ["1P 2M 3m 4P 5P 6M 7M", "melodic minor"],
+  ["1P 2M 3m 4P 5P 6m 7M", "harmonic minor"],
+  ["1P 2M 3M 4P 5P 6M 7m 7M", "bebop"],
+  ["1P 2M 3m 4P 5d 6m 6M 7M", "diminished", "whole-half diminished"],
+  // Modes
+  ["1P 2M 3m 4P 5P 6M 7m", "dorian"],
+  ["1P 2M 3M 4A 5P 6M 7M", "lydian"],
+  ["1P 2M 3M 4P 5P 6M 7m", "mixolydian", "dominant"],
+  ["1P 2m 3m 4P 5P 6m 7m", "phrygian"],
+  ["1P 2m 3m 4P 5d 6m 7m", "locrian"],
+  // 5-note scales
+  ["1P 3M 4P 5P 7M", "ionian pentatonic"],
+  ["1P 3M 4P 5P 7m", "mixolydian pentatonic", "indian"],
+  ["1P 2M 4P 5P 6M", "ritusen"],
+  ["1P 2M 4P 5P 7m", "egyptian"],
+  ["1P 3M 4P 5d 7m", "neopolitan major pentatonic"],
+  ["1P 3m 4P 5P 6m", "vietnamese 1"],
+  ["1P 2m 3m 5P 6m", "pelog"],
+  ["1P 2m 4P 5P 6m", "kumoijoshi"],
+  ["1P 2M 3m 5P 6m", "hirajoshi"],
+  ["1P 2m 4P 5d 7m", "iwato"],
+  ["1P 2m 4P 5P 7m", "in-sen"],
+  ["1P 3M 4A 5P 7M", "lydian pentatonic", "chinese"],
+  ["1P 3m 4P 6m 7m", "malkos raga"],
+  ["1P 3m 4P 5d 7m", "locrian pentatonic", "minor seven flat five pentatonic"],
+  ["1P 3m 4P 5P 7m", "minor pentatonic", "vietnamese 2"],
+  ["1P 3m 4P 5P 6M", "minor six pentatonic"],
+  ["1P 2M 3m 5P 6M", "flat three pentatonic", "kumoi"],
+  ["1P 2M 3M 5P 6m", "flat six pentatonic"],
+  ["1P 2m 3M 5P 6M", "scriabin"],
+  ["1P 3M 5d 6m 7m", "whole tone pentatonic"],
+  ["1P 3M 4A 5A 7M", "lydian #5P pentatonic"],
+  ["1P 3M 4A 5P 7m", "lydian dominant pentatonic"],
+  ["1P 3m 4P 5P 7M", "minor #7M pentatonic"],
+  ["1P 3m 4d 5d 7m", "super locrian pentatonic"],
+  // 6-note scales
+  ["1P 2M 3m 4P 5P 7M", "minor hexatonic"],
+  ["1P 2A 3M 5P 5A 7M", "augmented"],
+  ["1P 2M 4P 5P 6M 7m", "piongio"],
+  ["1P 2m 3M 4A 6M 7m", "prometheus neopolitan"],
+  ["1P 2M 3M 4A 6M 7m", "prometheus"],
+  ["1P 2m 3M 5d 6m 7m", "mystery #1"],
+  ["1P 2m 3M 4P 5A 6M", "six tone symmetric"],
+  ["1P 2M 3M 4A 5A 6A", "whole tone", "messiaen's mode #1"],
+  ["1P 2m 4P 4A 5P 7M", "messiaen's mode #5"],
+  // 7-note scales
+  ["1P 2M 3M 4P 5d 6m 7m", "locrian major", "arabian"],
+  ["1P 2m 3M 4A 5P 6m 7M", "double harmonic lydian"],
+  [
+    "1P 2m 2A 3M 4A 6m 7m",
+    "altered",
+    "super locrian",
+    "diminished whole tone",
+    "pomeroy"
+  ],
+  ["1P 2M 3m 4P 5d 6m 7m", "locrian #2", "half-diminished", "aeolian b5"],
+  [
+    "1P 2M 3M 4P 5P 6m 7m",
+    "mixolydian b6",
+    "melodic minor fifth mode",
+    "hindu"
+  ],
+  ["1P 2M 3M 4A 5P 6M 7m", "lydian dominant", "lydian b7", "overtone"],
+  ["1P 2M 3M 4A 5A 6M 7M", "lydian augmented"],
+  [
+    "1P 2m 3m 4P 5P 6M 7m",
+    "dorian b2",
+    "phrygian #6",
+    "melodic minor second mode"
+  ],
+  [
+    "1P 2m 3m 4d 5d 6m 7d",
+    "ultralocrian",
+    "superlocrian bb7",
+    "superlocrian diminished"
+  ],
+  ["1P 2m 3m 4P 5d 6M 7m", "locrian 6", "locrian natural 6", "locrian sharp 6"],
+  ["1P 2A 3M 4P 5P 5A 7M", "augmented heptatonic"],
+  // Source https://en.wikipedia.org/wiki/Ukrainian_Dorian_scale
+  [
+    "1P 2M 3m 4A 5P 6M 7m",
+    "dorian #4",
+    "ukrainian dorian",
+    "romanian minor",
+    "altered dorian"
+  ],
+  ["1P 2M 3m 4A 5P 6M 7M", "lydian diminished"],
+  ["1P 2M 3M 4A 5A 7m 7M", "leading whole tone"],
+  ["1P 2M 3M 4A 5P 6m 7m", "lydian minor"],
+  ["1P 2m 3M 4P 5P 6m 7m", "phrygian dominant", "spanish", "phrygian major"],
+  ["1P 2m 3m 4P 5P 6m 7M", "balinese"],
+  ["1P 2m 3m 4P 5P 6M 7M", "neopolitan major"],
+  ["1P 2M 3M 4P 5P 6m 7M", "harmonic major"],
+  ["1P 2m 3M 4P 5P 6m 7M", "double harmonic major", "gypsy"],
+  ["1P 2M 3m 4A 5P 6m 7M", "hungarian minor"],
+  ["1P 2A 3M 4A 5P 6M 7m", "hungarian major"],
+  ["1P 2m 3M 4P 5d 6M 7m", "oriental"],
+  ["1P 2m 3m 3M 4A 5P 7m", "flamenco"],
+  ["1P 2m 3m 4A 5P 6m 7M", "todi raga"],
+  ["1P 2m 3M 4P 5d 6m 7M", "persian"],
+  ["1P 2m 3M 5d 6m 7m 7M", "enigmatic"],
+  [
+    "1P 2M 3M 4P 5A 6M 7M",
+    "major augmented",
+    "major #5",
+    "ionian augmented",
+    "ionian #5"
+  ],
+  ["1P 2A 3M 4A 5P 6M 7M", "lydian #9"],
+  // 8-note scales
+  ["1P 2m 2M 4P 4A 5P 6m 7M", "messiaen's mode #4"],
+  ["1P 2m 3M 4P 4A 5P 6m 7M", "purvi raga"],
+  ["1P 2m 3m 3M 4P 5P 6m 7m", "spanish heptatonic"],
+  ["1P 2M 3m 3M 4P 5P 6M 7m", "bebop minor"],
+  ["1P 2M 3M 4P 5P 5A 6M 7M", "bebop major"],
+  ["1P 2m 3m 4P 5d 5P 6m 7m", "bebop locrian"],
+  ["1P 2M 3m 4P 5P 6m 7m 7M", "minor bebop"],
+  ["1P 2M 3M 4P 5d 5P 6M 7M", "ichikosucho"],
+  ["1P 2M 3m 4P 5P 6m 6M 7M", "minor six diminished"],
+  [
+    "1P 2m 3m 3M 4A 5P 6M 7m",
+    "half-whole diminished",
+    "dominant diminished",
+    "messiaen's mode #2"
+  ],
+  ["1P 3m 3M 4P 5P 6M 7m 7M", "kafi raga"],
+  ["1P 2M 3M 4P 4A 5A 6A 7M", "messiaen's mode #6"],
+  // 9-note scales
+  ["1P 2M 3m 3M 4P 5d 5P 6M 7m", "composite blues"],
+  ["1P 2M 3m 3M 4A 5P 6m 7m 7M", "messiaen's mode #3"],
+  // 10-note scales
+  ["1P 2m 2M 3m 4P 4A 5P 6m 6M 7M", "messiaen's mode #7"],
+  // 12-note scales
+  ["1P 2m 2M 3m 3M 4P 5d 5P 6m 6M 7m 7M", "chromatic"]
+];
+var data_default$1 = SCALES;
+var NoScaleType = {
+  ...EmptyPcset,
+  intervals: [],
+  aliases: []
+};
+var index$1 = {};
+function get$3(type) {
+  return index$1[type] || NoScaleType;
+}
+function add$1(intervals, name, aliases = []) {
+  const scale = { ...get$5(intervals), name, intervals, aliases };
+  index$1[scale.name] = scale;
+  index$1[scale.setNum] = scale;
+  index$1[scale.chroma] = scale;
+  scale.aliases.forEach((alias) => addAlias(scale, alias));
+  return scale;
+}
+function addAlias(scale, alias) {
+  index$1[alias] = scale;
+}
+data_default$1.forEach(
+  ([ivls, name, ...aliases]) => add$1(ivls.split(" "), name, aliases)
+);
+var NoChord = {
+  empty: true,
+  name: "",
+  symbol: "",
+  root: "",
+  bass: "",
+  rootDegree: 0,
+  type: "",
+  tonic: null,
+  setNum: NaN,
+  quality: "Unknown",
+  chroma: "",
+  normalized: "",
+  aliases: [],
+  notes: [],
+  intervals: []
+};
+function tokenize(name) {
+  const [letter, acc, oct, type] = tokenizeNote(name);
+  if (letter === "") {
+    return tokenizeBass("", name);
+  } else if (letter === "A" && type === "ug") {
+    return tokenizeBass("", "aug");
+  } else {
+    return tokenizeBass(letter + acc, oct + type);
+  }
+}
+function tokenizeBass(note2, chord2) {
+  const split = chord2.split("/");
+  if (split.length === 1) {
+    return [note2, split[0], ""];
+  }
+  const [letter, acc, oct, type] = tokenizeNote(split[1]);
+  if (letter !== "" && oct === "" && type === "") {
+    return [note2, split[0], letter + acc];
+  } else {
+    return [note2, chord2, ""];
+  }
+}
+function get$2(src) {
+  if (Array.isArray(src)) {
+    return getChord(src[1] || "", src[0], src[2]);
+  } else if (src === "") {
+    return NoChord;
+  } else {
+    const [tonic, type, bass] = tokenize(src);
+    const chord2 = getChord(type, tonic, bass);
+    return chord2.empty ? getChord(src) : chord2;
+  }
+}
+function getChord(typeName, optionalTonic, optionalBass) {
+  const type = get$4(typeName);
+  const tonic = note(optionalTonic || "");
+  const bass = note(optionalBass || "");
+  if (type.empty || optionalTonic && tonic.empty || optionalBass && bass.empty) {
+    return NoChord;
+  }
+  const bassInterval = distance(tonic.pc, bass.pc);
+  const bassIndex = type.intervals.indexOf(bassInterval);
+  const hasRoot = bassIndex >= 0;
+  const root = hasRoot ? bass : note("");
+  const rootDegree = bassIndex === -1 ? NaN : bassIndex + 1;
+  const hasBass = bass.pc && bass.pc !== tonic.pc;
+  const intervals = Array.from(type.intervals);
+  if (hasRoot) {
+    for (let i = 1; i < rootDegree; i++) {
+      const num = intervals[0][0];
+      const quality = intervals[0][1];
+      const newNum = parseInt(num, 10) + 7;
+      intervals.push(`${newNum}${quality}`);
+      intervals.shift();
+    }
+  } else if (hasBass) {
+    const ivl = subtract(distance(tonic.pc, bass.pc), "8P");
+    if (ivl) intervals.unshift(ivl);
+  }
+  const notes2 = tonic.empty ? [] : intervals.map((i) => transpose(tonic.pc, i));
+  typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
+  const symbol = `${tonic.empty ? "" : tonic.pc}${typeName}${hasRoot && rootDegree > 1 ? "/" + root.pc : hasBass ? "/" + bass.pc : ""}`;
+  const name = `${optionalTonic ? tonic.pc + " " : ""}${type.name}${hasRoot && rootDegree > 1 ? " over " + root.pc : hasBass ? " over " + bass.pc : ""}`;
+  return {
+    ...type,
+    name,
+    symbol,
+    tonic: tonic.pc,
+    type: type.name,
+    root: root.pc,
+    bass: hasBass ? bass.pc : "",
+    intervals,
+    rootDegree,
+    notes: notes2
+  };
+}
+var DATA = [
+  [
+    0.125,
+    "dl",
+    ["large", "duplex longa", "maxima", "octuple", "octuple whole"]
+  ],
+  [0.25, "l", ["long", "longa"]],
+  [0.5, "d", ["double whole", "double", "breve"]],
+  [1, "w", ["whole", "semibreve"]],
+  [2, "h", ["half", "minim"]],
+  [4, "q", ["quarter", "crotchet"]],
+  [8, "e", ["eighth", "quaver"]],
+  [16, "s", ["sixteenth", "semiquaver"]],
+  [32, "t", ["thirty-second", "demisemiquaver"]],
+  [64, "sf", ["sixty-fourth", "hemidemisemiquaver"]],
+  [128, "h", ["hundred twenty-eighth"]],
+  [256, "th", ["two hundred fifty-sixth"]]
+];
+var data_default = DATA;
+data_default.forEach(
+  ([denominator, shorthand, names2]) => add()
+);
+function add(denominator, shorthand, names2) {
+}
+function midiToFreq(midi, tuning = 440) {
+  return Math.pow(2, (midi - 69) / 12) * tuning;
+}
+var get$1 = note;
+var freq = (note2) => get$1(note2).freq;
+var MODES = [
+  [0, 2773, 0, "ionian", "", "Maj7", "major"],
+  [1, 2902, 2, "dorian", "m", "m7"],
+  [2, 3418, 4, "phrygian", "m", "m7"],
+  [3, 2741, -1, "lydian", "", "Maj7"],
+  [4, 2774, 1, "mixolydian", "", "7"],
+  [5, 2906, 3, "aeolian", "m", "m7", "minor"],
+  [6, 3434, 5, "locrian", "dim", "m7b5"]
+];
+var NoMode = {
+  ...EmptyPcset,
+  name: "",
+  alt: 0,
+  modeNum: NaN,
+  triad: "",
+  seventh: "",
+  aliases: []
+};
+var modes = MODES.map(toMode);
+var index = {};
+modes.forEach((mode2) => {
+  index[mode2.name] = mode2;
+  mode2.aliases.forEach((alias) => {
+    index[alias] = mode2;
+  });
+});
+function get(name) {
+  return typeof name === "string" ? index[name.toLowerCase()] || NoMode : name && name.name ? get(name.name) : NoMode;
+}
+function toMode(mode2) {
+  const [modeNum, setNum, alt, name, triad, seventh, alias] = mode2;
+  const aliases = alias ? [alias] : [];
+  const chroma = Number(setNum).toString(2);
+  const intervals = get$3(name).intervals;
+  return {
+    empty: false,
+    intervals,
+    modeNum,
+    chroma,
+    normalized: chroma,
+    name,
+    setNum,
+    alt,
+    triad,
+    seventh,
+    aliases
+  };
+}
+function chords(chords2) {
+  return (modeName, tonic) => {
+    const mode2 = get(modeName);
+    if (mode2.empty) return [];
+    const triads2 = rotate(mode2.modeNum, chords2);
+    const tonics = mode2.intervals.map((i) => transpose(tonic, i));
+    return triads2.map((triad, i) => tonics[i] + triad);
+  };
+}
+chords(MODES.map((x) => x[4]));
+chords(MODES.map((x) => x[5]));
+function midiToFrequency(midi) {
+  return midiToFreq(midi);
+}
+function noteToFrequency(note2) {
+  const freq$1 = freq(note2);
+  if (freq$1 === null) {
+    console.warn(`Invalid note: ${note2}, defaulting to A4 (440Hz)`);
+    return 440;
+  }
+  return freq$1;
+}
+function resolveChordNotes(notes) {
+  if (Array.isArray(notes)) {
+    return notes;
+  }
+  const [chordName, octaveStr] = notes.split(":");
+  const octave = octaveStr ? parseInt(octaveStr, 10) : 3;
+  const chord = get$2(chordName);
+  if (!chord.notes.length) {
+    console.warn(`Unknown chord: ${chordName}, defaulting to root note`);
+    return [chordName + octave];
+  }
+  const rootPc = chord.notes[0];
+  const noteOrder = ["C", "D", "E", "F", "G", "A", "B"];
+  const rootIndex = noteOrder.findIndex((n) => rootPc.startsWith(n));
+  return chord.notes.map((note2) => {
+    const noteIndex = noteOrder.findIndex((n) => note2.startsWith(n));
+    const noteOctave = noteIndex < rootIndex ? octave + 1 : octave;
+    return note2 + noteOctave;
+  });
+}
+function line(start, end, steps) {
+  if (steps < 1) {
+    throw new Error("Line must have at least 1 step");
+  }
+  const increment = (end - start) / steps;
+  return Array.from({ length: steps }, (_, i) => start + increment * i);
+}
+function mirror(values) {
+  return [...values, ...values.toReversed()];
+}
+function resolveCutoff(cutoff, stepIndex) {
+  if (typeof cutoff === "number") {
+    return midiToFrequency(cutoff);
+  }
+  const values = line(cutoff.from, cutoff.to, cutoff.steps);
+  const sequence = cutoff.mirror ? mirror(values) : values;
+  const effectiveStep = cutoff.step ?? stepIndex;
+  return midiToFrequency(sequence[effectiveStep % sequence.length]);
+}
+const SYNTH_PRESETS = {
+  /**
+   * Pure sine wave - clean, fundamental tone
+   */
+  sine: {
+    oscillator: "sine",
+    filter: { type: "lowpass", cutoff: 135.08, resonance: 1 },
+    voices: { count: 1, detune: 0, spread: 0 }
+  },
+  /**
+   * Sawtooth wave - bright, harmonically rich
+   */
+  saw: {
+    oscillator: "sawtooth",
+    filter: { type: "lowpass", cutoff: 135.08, resonance: 1 },
+    voices: { count: 1, detune: 0, spread: 0 }
+  },
+  /**
+   * Square wave - hollow, clarinet-like
+   */
+  square: {
+    oscillator: "square",
+    filter: { type: "lowpass", cutoff: 135.08, resonance: 1 },
+    voices: { count: 1, detune: 0, spread: 0 }
+  },
+  /**
+   * Triangle wave - soft, flute-like
+   */
+  tri: {
+    oscillator: "triangle",
+    filter: { type: "lowpass", cutoff: 135.08, resonance: 1 },
+    voices: { count: 1, detune: 0, spread: 0 }
+  },
+  /**
+   * Prophet - Sequential Circuits Prophet-5 inspired
+   * Warm analog sound with detuned voices and resonant filter
+   * Great for leads and pads
+   */
+  prophet: {
+    oscillator: "sawtooth",
+    filter: { type: "lowpass", cutoff: 102.23, resonance: 4 },
+    voices: { count: 3, detune: 12, spread: 0.5 }
+  },
+  /**
+   * Hollow - Ethereal pad sound
+   * Filtered square wave with soft resonance
+   * Good for atmospheric backgrounds
+   */
+  hollow: {
+    oscillator: "square",
+    filter: { type: "bandpass", cutoff: 86.37, resonance: 2 },
+    voices: { count: 2, detune: 8, spread: 0.7 }
+  },
+  /**
+   * Dark Ambience - Deep atmospheric pad
+   * Low-passed sawtooth with multiple detuned voices
+   */
+  dark_ambience: {
+    oscillator: "sawtooth",
+    filter: { type: "lowpass", cutoff: 79.35, resonance: 3 },
+    voices: { count: 4, detune: 15, spread: 0.8 }
+  },
+  /**
+   * Bass - Punchy bass sound
+   * Filtered sawtooth with slight detune for thickness
+   */
+  bass: {
+    oscillator: "sawtooth",
+    filter: { type: "lowpass", cutoff: 74.37, resonance: 5 },
+    voices: { count: 2, detune: 5, spread: 0.2 }
+  },
+  /**
+   * Pluck - Bright plucked string sound
+   * Square wave with high cutoff for attack brightness
+   */
+  pluck: {
+    oscillator: "square",
+    filter: { type: "lowpass", cutoff: 111.08, resonance: 2 },
+    voices: { count: 2, detune: 6, spread: 0.3 }
+  }
+};
+function getSynthPreset(type) {
+  return SYNTH_PRESETS[type];
+}
+const DEFAULT_SYNTH_CONFIG = SYNTH_PRESETS.sine;
+const SynthContext = createContext(null);
+function Synth({
+  type,
+  oscillator,
+  filter,
+  voices,
+  children
+}) {
+  const config = useMemo(() => {
+    const preset = getSynthPreset(type);
+    return {
+      oscillator: oscillator ?? preset.oscillator,
+      filter: {
+        type: filter?.type ?? preset.filter.type,
+        cutoff: filter?.cutoff ?? preset.filter.cutoff,
+        resonance: filter?.resonance ?? preset.filter.resonance
+      },
+      voices: {
+        count: voices?.count ?? preset.voices.count,
+        detune: voices?.detune ?? preset.voices.detune,
+        spread: voices?.spread ?? preset.voices.spread
+      }
+    };
+  }, [type, oscillator, filter, voices]);
+  return /* @__PURE__ */ jsx(SynthContext.Provider, { value: config, children });
+}
+function useSynth() {
+  const ctx = useContext(SynthContext);
+  return ctx ?? DEFAULT_SYNTH_CONFIG;
+}
+function Note({
+  note: note2,
+  amp = 0.3,
+  oscillator,
+  filter,
+  voices,
+  attack = ADSR_DEFAULTS.attack,
+  attack_level = ADSR_DEFAULTS.attack_level,
+  decay = ADSR_DEFAULTS.decay,
+  decay_level,
+  sustain = ADSR_DEFAULTS.sustain,
+  sustain_level = ADSR_DEFAULTS.sustain_level,
+  release = ADSR_DEFAULTS.release,
+  __stepIndex
+}) {
+  const uniqueId = useId();
+  const { audioContext, scheduler } = useTrack();
+  const scheduleNote = useScheduleNote();
+  const synthConfig = useSynth();
+  const oscillatorType = oscillator ?? synthConfig.oscillator;
+  const filterType = filter?.type ?? synthConfig.filter.type;
+  const filterCutoff = resolveCutoff(
+    filter?.cutoff ?? synthConfig.filter.cutoff,
+    __stepIndex ?? 0
+  );
+  const filterResonance = filter?.resonance ?? synthConfig.filter.resonance;
+  const voiceCount = voices?.count ?? synthConfig.voices.count;
+  const voiceDetune = voices?.detune ?? synthConfig.voices.detune;
+  const voiceSpread = voices?.spread ?? synthConfig.voices.spread;
+  const frequency = typeof note2 === "number" ? note2 : noteToFrequency(note2);
+  const adsrProps = {
+    attack,
+    attack_level,
+    decay,
+    decay_level,
+    sustain,
+    sustain_level,
+    release
+  };
+  useEffect(() => {
+    const playNote = (audioTime) => {
+      const gainNode = audioContext.createGain();
+      if (filterCutoff < 2e4) {
+        const filter2 = audioContext.createBiquadFilter();
+        filter2.type = filterType;
+        filter2.frequency.value = filterCutoff;
+        filter2.Q.value = filterResonance;
+        gainNode.connect(filter2);
+        filter2.connect(audioContext.destination);
+      } else {
+        gainNode.connect(audioContext.destination);
+      }
+      const endTime = applyADSREnvelope(
+        gainNode,
+        audioTime,
+        adsrProps,
+        amp / voiceCount,
+        // Normalize amplitude across voices
+        (beats) => scheduler.beatsToSeconds(beats)
+      );
+      for (let i = 0; i < voiceCount; i++) {
+        const oscillator2 = audioContext.createOscillator();
+        oscillator2.type = oscillatorType;
+        oscillator2.frequency.value = frequency;
+        if (voiceCount > 1 && voiceDetune > 0) {
+          const detuneOffset = (i / (voiceCount - 1) - 0.5) * voiceDetune;
+          oscillator2.detune.value = detuneOffset;
+        }
+        if (voiceCount > 1 && voiceSpread > 0) {
+          const panner = audioContext.createStereoPanner();
+          const panValue = (i / (voiceCount - 1) - 0.5) * 2 * voiceSpread;
+          panner.pan.value = panValue;
+          oscillator2.connect(panner);
+          panner.connect(gainNode);
+        } else {
+          oscillator2.connect(gainNode);
+        }
+        oscillator2.start(audioTime);
+        oscillator2.stop(endTime + 0.01);
+      }
+    };
+    scheduleNote.scheduleNote(uniqueId, playNote, __stepIndex);
+    return () => {
+      scheduleNote.unscheduleNote(uniqueId);
+    };
+  }, [
+    note2,
+    frequency,
+    amp,
+    oscillatorType,
+    filterCutoff,
+    filterResonance,
+    filterType,
+    voiceCount,
+    voiceDetune,
+    voiceSpread,
+    adsrProps,
+    audioContext,
+    scheduler,
+    scheduleNote,
+    __stepIndex,
+    uniqueId
+  ]);
+  return null;
+}
+const sampleCache = /* @__PURE__ */ new Map();
+function getSamplesDir() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageMain = require2.resolve("@react-synth/synth");
+    const packageDir = dirname(packageMain);
+    return join(packageDir, "..", "src", "samples");
+  } catch {
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFile);
+    return join(currentDir, "..", "samples");
+  }
+}
+const samplesDir = getSamplesDir();
+function getSamplePath(name) {
+  return join(samplesDir, `${name}.flac`);
+}
+async function loadSample(audioContext, name) {
+  if (sampleCache.has(name)) {
+    return sampleCache.get(name);
+  }
+  const path = getSamplePath(name);
+  const fileData = await readFile(path);
+  const audioBuffer = await audioContext.decodeAudioData(
+    fileData.buffer
+  );
+  sampleCache.set(name, audioBuffer);
+  return audioBuffer;
+}
+function Sample({
+  name,
+  amp = 1,
+  cutoff,
+  rate = 1,
+  pan = 0,
+  __stepIndex
+}) {
+  const uniqueId = useId();
+  const { audioContext } = useTrack();
+  const scheduleNote = useScheduleNote();
+  const filterCutoff = cutoff !== void 0 ? resolveCutoff(cutoff, __stepIndex ?? 0) : 2e4;
+  useEffect(() => {
+    let buffer = null;
+    loadSample(audioContext, name).then((loaded) => {
+      buffer = loaded;
+    });
+    const playSample = (audioTime) => {
+      if (!buffer) return;
+      const source = audioContext.createBufferSource();
+      source.buffer = buffer;
+      source.playbackRate.value = rate;
+      let currentNode = source;
+      if (filterCutoff < 2e4) {
+        const filter = audioContext.createBiquadFilter();
+        filter.type = "lowpass";
+        filter.frequency.value = filterCutoff;
+        currentNode.connect(filter);
+        currentNode = filter;
+      }
+      if (pan !== 0) {
+        const panner = audioContext.createStereoPanner();
+        panner.pan.value = pan;
+        currentNode.connect(panner);
+        currentNode = panner;
+      }
+      const gainNode = audioContext.createGain();
+      gainNode.gain.value = amp;
+      currentNode.connect(gainNode);
+      gainNode.connect(audioContext.destination);
+      source.start(audioTime);
+    };
+    scheduleNote.scheduleNote(uniqueId, playSample, __stepIndex);
+    return () => {
+      scheduleNote.unscheduleNote(uniqueId);
+    };
+  }, [
+    audioContext,
+    name,
+    scheduleNote,
+    uniqueId,
+    __stepIndex,
+    amp,
+    filterCutoff,
+    rate,
+    pan
+  ]);
+  return null;
+}
+function Chord({
+  notes,
+  amp = 0.3,
+  oscillator,
+  filter,
+  voices,
+  attack = ADSR_DEFAULTS.attack,
+  attack_level = ADSR_DEFAULTS.attack_level,
+  decay = ADSR_DEFAULTS.decay,
+  decay_level,
+  sustain = ADSR_DEFAULTS.sustain,
+  sustain_level = ADSR_DEFAULTS.sustain_level,
+  release = ADSR_DEFAULTS.release,
+  __stepIndex
+}) {
+  const uniqueId = useId();
+  const { audioContext, scheduler } = useTrack();
+  const { scheduleNote, unscheduleNote } = useScheduleNote();
+  const synthConfig = useSynth();
+  const oscillatorType = oscillator ?? synthConfig.oscillator;
+  const filterType = filter?.type ?? synthConfig.filter.type;
+  const filterCutoff = resolveCutoff(
+    filter?.cutoff ?? synthConfig.filter.cutoff,
+    __stepIndex ?? 0
+  );
+  const filterResonance = filter?.resonance ?? synthConfig.filter.resonance;
+  const voiceCount = voices?.count ?? synthConfig.voices.count;
+  const voiceDetune = voices?.detune ?? synthConfig.voices.detune;
+  const voiceSpread = voices?.spread ?? synthConfig.voices.spread;
+  const resolvedNotes = resolveChordNotes(notes);
+  const frequencies = resolvedNotes.map(
+    (note2) => typeof note2 === "number" ? note2 : noteToFrequency(note2)
+  );
+  const adsrProps = {
+    attack,
+    attack_level,
+    decay,
+    decay_level,
+    sustain,
+    sustain_level,
+    release
+  };
+  const totalOscillators = frequencies.length * voiceCount;
+  useEffect(() => {
+    const playChord = (audioTime) => {
+      const gainNode = audioContext.createGain();
+      if (filterCutoff < 2e4) {
+        const filter2 = audioContext.createBiquadFilter();
+        filter2.type = filterType;
+        filter2.frequency.value = filterCutoff;
+        filter2.Q.value = filterResonance;
+        gainNode.connect(filter2);
+        filter2.connect(audioContext.destination);
+      } else {
+        gainNode.connect(audioContext.destination);
+      }
+      const endTime = applyADSREnvelope(
+        gainNode,
+        audioTime,
+        adsrProps,
+        amp / totalOscillators,
+        // Normalize amplitude across all oscillators
+        (beats) => scheduler.beatsToSeconds(beats)
+      );
+      for (const frequency of frequencies) {
+        for (let i = 0; i < voiceCount; i++) {
+          const oscillator2 = audioContext.createOscillator();
+          oscillator2.type = oscillatorType;
+          oscillator2.frequency.value = frequency;
+          if (voiceCount > 1 && voiceDetune > 0) {
+            const detuneOffset = (i / (voiceCount - 1) - 0.5) * voiceDetune;
+            oscillator2.detune.value = detuneOffset;
+          }
+          if (voiceCount > 1 && voiceSpread > 0) {
+            const panner = audioContext.createStereoPanner();
+            const panValue = (i / (voiceCount - 1) - 0.5) * 2 * voiceSpread;
+            panner.pan.value = panValue;
+            oscillator2.connect(panner);
+            panner.connect(gainNode);
+          } else {
+            oscillator2.connect(gainNode);
+          }
+          oscillator2.start(audioTime);
+          oscillator2.stop(endTime + 0.01);
+        }
+      }
+    };
+    scheduleNote(uniqueId, playChord, __stepIndex);
+    return () => {
+      unscheduleNote(uniqueId);
+    };
+  }, [
+    notes,
+    frequencies,
+    amp,
+    oscillatorType,
+    filterCutoff,
+    filterResonance,
+    filterType,
+    voiceCount,
+    voiceDetune,
+    voiceSpread,
+    totalOscillators,
+    adsrProps,
+    audioContext,
+    scheduler,
+    scheduleNote,
+    unscheduleNote,
+    __stepIndex,
+    uniqueId
+  ]);
+  return null;
+}
+function Sequence({
+  interval: interval2,
+  children,
+  __stepIndex
+}) {
+  const uniqueId = useId();
+  const { scheduler } = useTrack();
+  const { scheduleNote, unscheduleNote } = useScheduleNote();
+  const childArray = Children.toArray(children);
+  const totalSteps = childArray.length;
+  const stepCallbacks = React.useRef(/* @__PURE__ */ new Map());
+  const idToStepIndex = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    const sequenceCallback = (audioTime, beatTime) => {
+      for (let i = 0; i < totalSteps; i++) {
+        const stepOffset = scheduler.beatsToSeconds(i * interval2);
+        const stepAudioTime = audioTime + stepOffset;
+        const stepBeatTime = beatTime + i * interval2;
+        const callback = stepCallbacks.current.get(i);
+        if (callback) {
+          callback(stepAudioTime, stepBeatTime);
+        }
+      }
+    };
+    scheduleNote(`seq-${uniqueId}`, sequenceCallback, __stepIndex);
+    return () => {
+      unscheduleNote(`seq-${uniqueId}`);
+    };
+  }, [
+    interval2,
+    totalSteps,
+    scheduler,
+    uniqueId,
+    scheduleNote,
+    unscheduleNote,
+    __stepIndex
+  ]);
+  const scheduleContextValue = useMemo(
+    () => ({
+      scheduleNote: (noteId, callback, stepIndex) => {
+        if (stepIndex !== void 0) {
+          idToStepIndex.current.set(noteId, stepIndex);
+          stepCallbacks.current.set(stepIndex, callback);
+        }
+      },
+      unscheduleNote: (noteId) => {
+        const stepIndex = idToStepIndex.current.get(noteId);
+        if (stepIndex !== void 0) {
+          stepCallbacks.current.delete(stepIndex);
+          idToStepIndex.current.delete(noteId);
+        }
+      }
+    }),
+    []
+  );
+  const childrenWithIndex = childArray.map((child, index2) => {
+    if (isValidElement(child)) {
+      return cloneElement(child, {
+        key: `step-${index2}`,
+        __stepIndex: index2
+      });
+    }
+    return child;
+  });
+  return /* @__PURE__ */ jsx(ScheduleNoteContext.Provider, { value: scheduleContextValue, children: childrenWithIndex });
+}
+export {
+  ADSR_DEFAULTS,
+  Chord,
+  DEFAULT_SYNTH_CONFIG,
+  Loop,
+  Note,
+  SYNTH_PRESETS,
+  Sample,
+  ScheduleNoteContext,
+  Scheduler,
+  Sequence,
+  Synth,
+  Track,
+  applyADSREnvelope,
+  getScheduler,
+  getSynthPreset,
+  line,
+  midiToFrequency,
+  mirror,
+  noteToFrequency,
+  resetScheduler,
+  resolveChordNotes,
+  resolveCutoff,
+  useScheduleNote,
+  useSynth,
+  useTrack
+};
+//# sourceMappingURL=index.js.map