@tspro/web-music-score 1.1.0 → 2.0.0

package/dist/theory/index.mjs

@@ -0,0 +1,1716 @@
+/* WebMusicScore v2.0.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
+import {
+  __publicField
+} from "../chunk-2EPWQZKJ.mjs";
+
+// src/theory/chord.ts
+import { Utils as Utils6 } from "@tspro/ts-utils-lib";
+
+// src/theory/note.ts
+import { Utils as Utils2 } from "@tspro/ts-utils-lib";
+
+// src/theory/types.ts
+import { Utils } from "@tspro/ts-utils-lib";
+import { MusicError, MusicErrorType } from "@tspro/web-music-score/core";
+var SymbolSet = /* @__PURE__ */ ((SymbolSet2) => {
+  SymbolSet2[SymbolSet2["Ascii"] = 0] = "Ascii";
+  SymbolSet2[SymbolSet2["Unicode"] = 1] = "Unicode";
+  return SymbolSet2;
+})(SymbolSet || {});
+var PitchNotation = /* @__PURE__ */ ((PitchNotation2) => {
+  PitchNotation2[PitchNotation2["Scientific"] = 0] = "Scientific";
+  PitchNotation2[PitchNotation2["Helmholtz"] = 1] = "Helmholtz";
+  return PitchNotation2;
+})(PitchNotation || {});
+var PitchNotationList = Utils.Enum.getEnumValues(PitchNotation);
+var DefaultPitchNotation = 0 /* Scientific */;
+function validatePitchNotation(pn) {
+  if (!Utils.Is.isEnumValue(pn, PitchNotation)) {
+    throw new MusicError(MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
+  } else {
+    return pn;
+  }
+}
+function getPitchNotationName(pn) {
+  return PitchNotation[validatePitchNotation(pn)];
+}
+var GuitarNoteLabel = /* @__PURE__ */ ((GuitarNoteLabel2) => {
+  GuitarNoteLabel2["Default"] = "Default";
+  GuitarNoteLabel2["OmitOctave"] = "Omit Octave";
+  GuitarNoteLabel2["Interval"] = "Interval";
+  return GuitarNoteLabel2;
+})(GuitarNoteLabel || {});
+var DefaultGuitarNoteLabel = "Default" /* Default */;
+var GuitarNoteLabelList = Utils.Enum.getEnumValues(GuitarNoteLabel);
+function validateGuitarNoteLabel(label) {
+  if (!Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
+    throw new MusicError(MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
+  } else {
+    return label;
+  }
+}
+
+// src/theory/note.ts
+import { MusicError as MusicError2, MusicErrorType as MusicErrorType2 } from "@tspro/web-music-score/core";
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+var C0_chromaticId = 12;
+var C0_diatonicId = 7;
+var AccidentalAsciiSymbolMap = /* @__PURE__ */ new Map([[-2, "bb"], [-1, "b"], [0, ""], [1, "#"], [2, "x"]]);
+var AccidentalUnicodeSymbolMap = /* @__PURE__ */ new Map([[-2, "\u{1D12B}"], [-1, "\u266D"], [0, ""], [1, "\u266F"], [2, "\u{1D12A}"]]);
+var AccidentalMap = /* @__PURE__ */ new Map([["", 0], ["bb", -2], ["b", -1], ["#", 1], ["x", 2], ["\u{1D12B}", -2], ["\u266D", -1], ["\u266F", 1], ["\u{1D12A}", 2]]);
+var NoteLetters = ["C", "D", "E", "F", "G", "A", "B"];
+var DiatonicToChromaticMap = [0, 2, 4, 5, 7, 9, 11];
+var NoteNameRegex = /^([A-G])((?:bb|𝄫|♭|b|#|♯|x|𝄪)?)?(-?\d+)?$/;
+var _Note = class _Note {
+  constructor(arg, accidental, octave) {
+    __publicField(this, "diatonicClass");
+    __publicField(this, "accidental");
+    __publicField(this, "octave");
+    if (typeof arg === "number" && typeof accidental === "number" && octave === void 0) {
+      _Note.validateDiatonicId(arg);
+      this.diatonicClass = _Note.getDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.getOctaveFromDiatonicId(arg);
+    } else if (typeof arg === "number" && typeof accidental === "number" && typeof octave === "number") {
+      this.diatonicClass = _Note.validateDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.validateOctave(octave);
+    } else if (typeof arg === "string" && typeof accidental === "number" && typeof octave === "number") {
+      this.diatonicClass = _Note.getDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.validateOctave(octave);
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid args: ${arg}, ${accidental}, ${octave}`);
+    }
+  }
+  get diatonicId() {
+    return _Note.getDiatonicIdInOctave(this.diatonicClass, this.octave);
+  }
+  get chromaticId() {
+    return _Note.getChromaticIdInOctave(DiatonicToChromaticMap[this.diatonicClass] + this.accidental, this.octave);
+  }
+  get midiNumber() {
+    return this.chromaticId;
+  }
+  get chromaticClass() {
+    return _Note.getChromaticClass(DiatonicToChromaticMap[this.diatonicClass] + this.accidental);
+  }
+  get noteLetter() {
+    return NoteLetters[this.diatonicClass];
+  }
+  format(pitchNotation, symbolSet) {
+    let { noteLetter, octave } = this;
+    let accidentalSymbol = _Note.getAccidentalSymbol(this.accidental, symbolSet);
+    if (pitchNotation === 1 /* Helmholtz */) {
+      if (octave >= 3) {
+        return noteLetter.toLowerCase() + accidentalSymbol + "\u2032".repeat(octave - 3);
+      } else {
+        return noteLetter.toUpperCase() + accidentalSymbol + "\u0375".repeat(2 - octave);
+      }
+    } else {
+      return noteLetter + accidentalSymbol + octave;
+    }
+  }
+  formatOmitOctave(symbolSet) {
+    let noteLetter = NoteLetters[this.diatonicClass];
+    let accidental = _Note.getAccidentalSymbol(this.accidental, symbolSet);
+    return noteLetter + accidental;
+  }
+  static getNote(noteName) {
+    let note = this.noteByNameCache.get(noteName);
+    if (note === void 0) {
+      let p = _Note.parseNote(noteName);
+      if (!p) {
+        throw new MusicError2(MusicErrorType2.Note, `Invalid noteName: ${noteName}`);
+      }
+      if (p.octave === void 0) {
+        throw new MusicError2(MusicErrorType2.Note, `Octave is required for note.`);
+      }
+      note = new _Note(p.noteLetter, p.accidental, p.octave);
+      this.noteByNameCache.set(noteName, note);
+    }
+    return note;
+  }
+  static getChromaticNote(chromaticId) {
+    let note = this.chromaticNoteCache.get(chromaticId);
+    if (note === void 0) {
+      const NoteNameList = ["C/B#", "C#/Db", "D", "D#/Eb", "E/Fb", "F/E#", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B/Cb"];
+      let noteName = NoteNameList[_Note.getChromaticClass(chromaticId)].split("/")[0] + _Note.getOctaveFromChromaticId(chromaticId);
+      let p = _Note.parseNote(noteName);
+      if (!p) {
+        throw new MusicError2(MusicErrorType2.Note, `Invalid noteName: ${noteName}`);
+      }
+      if (p.octave === void 0) {
+        throw new MusicError2(MusicErrorType2.Note, `Octave is required for note.`);
+      }
+      note = new _Note(p.noteLetter, p.accidental, p.octave);
+      this.chromaticNoteCache.set(chromaticId, note);
+    }
+    return note;
+  }
+  static getDiatonicClass(arg) {
+    if (typeof arg === "number") {
+      return mod(arg, 7);
+    } else if (typeof arg === "string" && arg.length > 0) {
+      return NoteLetters.indexOf(_Note.validateNoteLetter(arg[0]));
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid arg: ${arg}`);
+    }
+  }
+  static getOctaveFromDiatonicId(diatonicId) {
+    return Math.floor((diatonicId - C0_diatonicId) / 7);
+  }
+  static getDiatonicIdInOctave(diatonicId, octave) {
+    return _Note.getDiatonicClass(diatonicId) + octave * 7 + C0_diatonicId;
+  }
+  static getChromaticClass(chromaticId) {
+    return mod(chromaticId, 12);
+  }
+  static getOctaveFromChromaticId(chromaticId) {
+    return Math.floor((chromaticId - C0_chromaticId) / 12);
+  }
+  static getChromaticIdInOctave(chromaticId, octave) {
+    return _Note.getChromaticClass(chromaticId) + octave * 12 + C0_chromaticId;
+  }
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.diatonicId === b.diatonicId && a.accidental === b.accidental;
+    }
+  }
+  static replaceAccidentalSymbols(str, symbolSet) {
+    if (symbolSet === 1 /* Unicode */) {
+      return str.replace("bb", "\u{1D12B}").replace("b", "\u266D").replace("#", "\u266F").replace("x", "\u{1D12A}");
+    } else {
+      return str.replace("\u{1D12B}", "bb").replace("\u266D", "b").replace("\u266F", "#").replace("\u{1D12A}", "x");
+    }
+  }
+  static isValidNoteName(noteName) {
+    return NoteNameRegex.test(noteName);
+  }
+  static parseNote(noteName) {
+    var _a;
+    let m = NoteNameRegex.exec(noteName);
+    if (!m) {
+      return void 0;
+    }
+    let noteLetter = _Note.validateNoteLetter(m[1]);
+    let accidentalStr = m[2];
+    let accidental = _Note.validateAccidental((_a = AccidentalMap.get(accidentalStr)) != null ? _a : 0);
+    let octaveStr = m[3];
+    let octave = octaveStr ? _Note.validateOctave(+octaveStr) : void 0;
+    return { noteLetter, accidental, octave };
+  }
+  static getScientificNoteName(noteName, symbolSet) {
+    let p = _Note.parseNote(noteName);
+    if (!p) {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid noteName: ${noteName}`);
+    }
+    let { noteLetter, accidental, octave } = p;
+    return noteLetter + _Note.getAccidentalSymbol(accidental, symbolSet) + (octave != null ? octave : "");
+  }
+  static getAccidentalSymbol(accidental, symbolsSet) {
+    return symbolsSet === 1 /* Unicode */ ? AccidentalUnicodeSymbolMap.get(accidental) : AccidentalAsciiSymbolMap.get(accidental);
+  }
+  static getAccidental(accidentalSymbol) {
+    let accidental = AccidentalMap.get(accidentalSymbol);
+    if (accidental === void 0) {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid accidental: ${accidentalSymbol}`);
+    }
+    return accidental;
+  }
+  static getNoteLetter(diatonicId) {
+    return NoteLetters[_Note.getDiatonicClass(diatonicId)];
+  }
+  static findNextDiatonicIdAbove(diatonicId, bottomDiatonicId, addOctaveIfEqual) {
+    let diatonicClass = _Note.getDiatonicClass(diatonicId);
+    let bottomDiatonicClass = _Note.getDiatonicClass(bottomDiatonicId);
+    let addOctave = addOctaveIfEqual ? diatonicClass <= bottomDiatonicClass ? 1 : 0 : diatonicClass < bottomDiatonicClass ? 1 : 0;
+    return _Note.getDiatonicIdInOctave(diatonicClass, _Note.getOctaveFromDiatonicId(bottomDiatonicId) + addOctave);
+  }
+  static validateDiatonicId(diatonicId) {
+    if (Utils2.Is.isInteger(diatonicId)) {
+      return diatonicId;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicId: ${diatonicId}`);
+    }
+  }
+  static validateDiatonicClass(diatonicClass) {
+    if (Utils2.Is.isInteger(diatonicClass) && diatonicClass >= 0 && diatonicClass < 7) {
+      return diatonicClass;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicClass: ${diatonicClass}`);
+    }
+  }
+  static validateChromaticId(chromaticId) {
+    if (Utils2.Is.isInteger(chromaticId)) {
+      return chromaticId;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticId: ${chromaticId}`);
+    }
+  }
+  static validatechromaticClass(chromaticClass) {
+    if (Utils2.Is.isInteger(chromaticClass) && chromaticClass >= 0 && chromaticClass < 12) {
+      return chromaticClass;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticClass: ${chromaticClass}`);
+    }
+  }
+  static validateNoteLetter(note) {
+    if (NoteLetters.some((n) => n === note)) {
+      return note;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid note: ${note}`);
+    }
+  }
+  static validateOctave(octave) {
+    if (Utils2.Is.isInteger(octave)) {
+      return octave;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid octave: ${octave}`);
+    }
+  }
+  static validateAccidental(acc) {
+    if (Utils2.Is.isInteger(acc) && acc >= -2 && acc <= 2) {
+      return acc;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid accidental: ${acc}`);
+    }
+  }
+  /**
+   * Sort notes by diatonicId in ascending order.
+   * @param notes - Array of notes.
+   * @returns Sorted array of notes.
+   */
+  static sort(notes) {
+    return notes.slice().sort(_Note.compareFunc);
+  }
+  /**
+   * Remove duplicate notes.
+   * @param notes - Array of notes.
+   * @returns Sorted set of notes.
+   */
+  static removeDuplicates(notes) {
+    let uniqueSet = [];
+    notes.forEach((note) => {
+      if (uniqueSet.find((n) => _Note.equals(note, n)) === void 0) {
+        uniqueSet.push(note);
+      }
+    });
+    return uniqueSet;
+  }
+  static compareFunc(a, b) {
+    if (a.diatonicId < b.diatonicId) {
+      return -1;
+    } else if (a.diatonicId > b.diatonicId) {
+      return 1;
+    } else {
+      if (a.accidental < b.accidental) {
+        return -1;
+      } else if (a.accidental > b.accidental) {
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  }
+};
+__publicField(_Note, "noteByNameCache", /* @__PURE__ */ new Map());
+__publicField(_Note, "chromaticNoteCache", /* @__PURE__ */ new Map());
+var Note = _Note;
+
+// src/theory/scale.ts
+import { Utils as Utils5 } from "@tspro/ts-utils-lib";
+
+// src/theory/key-signature.ts
+import { Utils as Utils3 } from "@tspro/ts-utils-lib";
+import { MusicError as MusicError3, MusicErrorType as MusicErrorType3 } from "@tspro/web-music-score/core";
+function getAccidental(chromaticId, diatonicId) {
+  let a = Note.getChromaticClass(chromaticId) - new Note(diatonicId, 0).chromaticClass;
+  while (a > 2) {
+    a -= 12;
+  }
+  while (a < -2) {
+    a += 12;
+  }
+  return Note.validateAccidental(a);
+}
+var DegreeRule = /^(bb?|b?|#?|x?)([0-9]*)$/;
+function parseDegree(degree) {
+  var _a, _b;
+  let m = DegreeRule.exec("" + degree);
+  if (!m) {
+    throw new MusicError3(MusicErrorType3.KeySignature, `Invalid degree: ${degree}`);
+  }
+  let acc = (_b = Note.getAccidental((_a = m[1]) != null ? _a : "")) != null ? _b : 0;
+  let deg = +m[2];
+  if (!Utils3.Is.isInteger(acc) || acc < -2 || acc > 2 || !Utils3.Is.isInteger(deg) || deg < 1) {
+    throw new MusicError3(MusicErrorType3.KeySignature, `Invalid degree: ${degree}`);
+  } else {
+    return { deg, acc };
+  }
+}
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["Ionian"] = 1] = "Ionian";
+  Mode2[Mode2["Dorian"] = 2] = "Dorian";
+  Mode2[Mode2["Phrygian"] = 3] = "Phrygian";
+  Mode2[Mode2["Lydian"] = 4] = "Lydian";
+  Mode2[Mode2["Mixolydian"] = 5] = "Mixolydian";
+  Mode2[Mode2["Aeolian"] = 6] = "Aeolian";
+  Mode2[Mode2["Locrian"] = 7] = "Locrian";
+  return Mode2;
+})(Mode || {});
+var AccidentalType = /* @__PURE__ */ ((AccidentalType2) => {
+  AccidentalType2[AccidentalType2["Natural"] = 0] = "Natural";
+  AccidentalType2[AccidentalType2["Flats"] = 1] = "Flats";
+  AccidentalType2[AccidentalType2["Sharps"] = 2] = "Sharps";
+  return AccidentalType2;
+})(AccidentalType || {});
+function getDefaultKeySignature() {
+  return getScale("C", "Major" /* Major */);
+}
+var _KeySignature = class _KeySignature {
+  /**
+   * @param tonic - Tonic/root note.
+   * @param mode - Mode: Ionian/Major = 1, Dorian = 2, ..., Locrian = 7
+   */
+  constructor(tonic, mode) {
+    this.tonic = tonic;
+    this.mode = mode;
+    __publicField(this, "naturalScaleNotes");
+    __publicField(this, "accidentalByDiatonicClass");
+    __publicField(this, "orderedAccidentedNotes");
+    if (!Utils3.Is.isEnumValue(mode, Mode)) {
+      throw new MusicError3(MusicErrorType3.KeySignature, `Invalid mode: ${mode}`);
+    }
+    let intervals = [2, 2, 1, 2, 2, 2, 1];
+    for (let i = 1; i < mode; i++) {
+      intervals.push(intervals.shift());
+    }
+    this.naturalScaleNotes = [];
+    this.accidentalByDiatonicClass = [];
+    let diatonicId = Note.getDiatonicClass(tonic[0]);
+    let chromaticId = Note.getNote(tonic + "0").chromaticId;
+    for (let id = 0; id < 7; diatonicId++, chromaticId += intervals[id], id++) {
+      let note = new Note(Note.getDiatonicClass(diatonicId), getAccidental(chromaticId, diatonicId));
+      if (Math.abs(note.accidental) >= 2) {
+        throw new MusicError3(MusicErrorType3.KeySignature, "Key signature contains double accidental.");
+      }
+      this.naturalScaleNotes[id] = note;
+      this.accidentalByDiatonicClass[note.diatonicClass] = note.accidental;
+    }
+    let sharps = this.naturalScaleNotes.filter((n) => n.accidental > 0).sort((a, b) => {
+      let ai = _KeySignature.OrderOfSharps.indexOf(a.noteLetter);
+      let bi = _KeySignature.OrderOfSharps.indexOf(b.noteLetter);
+      if (ai === -1 || bi === -1) {
+        throw new MusicError3(MusicErrorType3.KeySignature, "Unexpected note in key signature.");
+      }
+      return ai - bi;
+    });
+    let flats = this.naturalScaleNotes.filter((n) => n.accidental < 0).sort((a, b) => {
+      let ai = _KeySignature.OrderOfFlats.indexOf(a.noteLetter);
+      let bi = _KeySignature.OrderOfFlats.indexOf(b.noteLetter);
+      if (ai === -1 || bi === -1) {
+        throw new MusicError3(MusicErrorType3.KeySignature, "Unexpected note in key signature.");
+      }
+      return ai - bi;
+    });
+    if (sharps.length !== 0 && flats.length !== 0) {
+      throw new MusicError3(MusicErrorType3.KeySignature, "Key Signature has both sharps and flats.");
+    }
+    this.orderedAccidentedNotes = flats.length > 0 ? flats : sharps;
+  }
+  getAccidentalType() {
+    if (this.orderedAccidentedNotes.length === 0) {
+      return 0 /* Natural */;
+    } else if (this.orderedAccidentedNotes[0].accidental < 0) {
+      return 1 /* Flats */;
+    } else {
+      return 2 /* Sharps */;
+    }
+  }
+  getNaturalScaleNotes() {
+    return this.naturalScaleNotes;
+  }
+  getAccidental(diatonicId) {
+    var _a;
+    return (_a = this.accidentalByDiatonicClass[Note.getDiatonicClass(diatonicId)]) != null ? _a : 0;
+  }
+  getNumAccidentals() {
+    return this.orderedAccidentedNotes.length;
+  }
+  getOrderedAccidentalNotes() {
+    return this.orderedAccidentedNotes;
+  }
+  /**
+   * 
+   * @param degree - number 1..7 or string e.g "b5" or "#4"
+   * @returns 
+   */
+  getNoteByDegree(degree) {
+    let { deg, acc } = parseDegree(degree);
+    if (acc === 0) {
+      return this.naturalScaleNotes[(deg - 1) % 7];
+    } else {
+      let note = this.naturalScaleNotes[(deg - 1) % 7];
+      return new Note(note.diatonicId, note.accidental + acc);
+    }
+  }
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.tonic === b.tonic && a.mode === b.mode;
+    }
+  }
+};
+__publicField(_KeySignature, "OrderOfSharps", "FCGDAEB");
+__publicField(_KeySignature, "OrderOfFlats", "BEADGCF");
+var KeySignature = _KeySignature;
+
+// src/theory/interval.ts
+import { Utils as Utils4 } from "@tspro/ts-utils-lib";
+import { MusicError as MusicError4, MusicErrorType as MusicErrorType4 } from "@tspro/web-music-score/core";
+var IntervalQualityAbbrMap = /* @__PURE__ */ new Map([
+  ["Major", "M"],
+  ["minor", "m"],
+  ["Perfect", "P"],
+  ["diminished", "d"],
+  ["Augmented", "A"],
+  ["doubly diminished", "dd"],
+  ["Doubly Augmented", "AA"]
+]);
+var IntervalQualities = {
+  "1": {
+    // Unison
+    "0": "Perfect",
+    "1": "Augmented",
+    "-1": "diminished",
+    "2": "Doubly Augmented",
+    "-2": "doubly diminished"
+  },
+  "2": {
+    // Second
+    "2": "Major",
+    "1": "minor",
+    "3": "Augmented",
+    "0": "diminished",
+    "4": "Doubly Augmented",
+    "-1": "doubly diminished"
+  },
+  "3": {
+    // Third
+    "4": "Major",
+    "3": "minor",
+    "5": "Augmented",
+    "2": "diminished",
+    "6": "Doubly Augmented",
+    "1": "doubly diminished"
+  },
+  "4": {
+    // Fourth
+    "5": "Perfect",
+    "6": "Augmented",
+    "4": "diminished",
+    "7": "Doubly Augmented",
+    "3": "doubly diminished"
+  },
+  "5": {
+    // Fifth
+    "7": "Perfect",
+    "8": "Augmented",
+    "6": "diminished",
+    "9": "Doubly Augmented",
+    "5": "doubly diminished"
+  },
+  "6": {
+    // Sixth
+    "9": "Major",
+    "8": "minor",
+    "10": "Augmented",
+    "7": "diminished",
+    "11": "Doubly Augmented",
+    "6": "doubly diminished"
+  },
+  "7": {
+    // Seventh
+    "11": "Major",
+    "10": "minor",
+    "12": "Augmented",
+    "9": "diminished",
+    "13": "Doubly Augmented",
+    "8": "doubly diminished"
+  },
+  "8": {
+    // Octave
+    "12": "Perfect",
+    "13": "Augmented",
+    "11": "diminished",
+    "14": "Doubly Augmented",
+    "10": "doubly diminished"
+  }
+};
+function getIntervalQuality(diatonicInterval, chromaticInterval) {
+  while (diatonicInterval < 1) {
+    diatonicInterval += 7;
+    chromaticInterval += 12;
+  }
+  while (diatonicInterval > 8) {
+    diatonicInterval -= 7;
+    chromaticInterval -= 12;
+  }
+  const qualities = IntervalQualities[diatonicInterval];
+  if (qualities) {
+    return qualities[chromaticInterval];
+  } else {
+    return void 0;
+  }
+}
+function validateIntervalQuality(q) {
+  if (!(q === "Perfect" || q === "Major" || q === "minor" || q === "Augmented" || q === "diminished" || q === "Doubly Augmented" || q === "doubly diminished")) {
+    throw new MusicError4(MusicErrorType4.InvalidArg, `Invalid interval quality: ${q}`);
+  } else {
+    return q;
+  }
+}
+function formatQuantity(q) {
+  if (!Utils4.Is.isIntegerGte(q, 1)) {
+    throw new MusicError4(MusicErrorType4.InvalidArg, `Invalid interval quantity: ${q}`);
+  } else {
+    return Utils4.Math.toOrdinalNumber(q);
+  }
+}
+var InvalidIntervalException = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.msg = msg;
+    this.name = "InvalidInterval";
+  }
+};
+var Interval = class _Interval {
+  constructor(note1, note2) {
+    this.note1 = note1;
+    this.note2 = note2;
+    __publicField(this, "direction");
+    __publicField(this, "semitones");
+    __publicField(this, "quantity");
+    __publicField(this, "quality");
+    if (note2.diatonicId >= note1.diatonicId) {
+      this.direction = note2.diatonicId === note1.diatonicId ? "Unison" : "Ascending";
+      this.quantity = note2.diatonicId - note1.diatonicId + 1;
+      this.semitones = note2.chromaticId - note1.chromaticId;
+    } else {
+      this.direction = "Descending";
+      this.quantity = note1.diatonicId - note2.diatonicId + 1;
+      this.semitones = note1.chromaticId - note2.chromaticId;
+    }
+    let quality = getIntervalQuality(this.quantity, this.semitones);
+    if (quality) {
+      this.quality = quality;
+    } else {
+      throw new InvalidIntervalException("Unknown interval quality");
+    }
+  }
+  static get(note1, note2) {
+    try {
+      return new _Interval(note1, note2);
+    } catch (err) {
+      if (err instanceof InvalidIntervalException) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  toString() {
+    let direction = this.direction === "Unison" ? "" : this.direction + " ";
+    let quality = this.quality + " ";
+    let quantity = this.direction === "Unison" ? "Unison" : formatQuantity(this.quantity);
+    return direction + quality + quantity;
+  }
+  toAbbrString() {
+    var _a;
+    let direction = this.direction === "Descending" ? "\u2193" : "";
+    let quality = (_a = IntervalQualityAbbrMap.get(this.quality)) != null ? _a : "?";
+    let quantity = this.quantity;
+    return direction + quality + quantity;
+  }
+};
+
+// src/theory/scale.ts
+import { MusicError as MusicError5, MusicErrorType as MusicErrorType5 } from "@tspro/web-music-score/core";
+function getNaturalDiatonicId(chromaticId) {
+  let diatonicClass = Note.getDiatonicClass("CCDDEFFGGAAB"[Note.getChromaticClass(chromaticId)]);
+  let octave = Note.getOctaveFromChromaticId(chromaticId);
+  return Note.getDiatonicIdInOctave(diatonicClass, octave);
+}
+var FullTonicList = [
+  "Cb",
+  "C",
+  "C#",
+  "Db",
+  "D",
+  "D#",
+  "Eb",
+  "E",
+  "E#",
+  "Fb",
+  "F",
+  "F#",
+  "Gb",
+  "G",
+  "G#",
+  "Ab",
+  "A",
+  "A#",
+  "Bb",
+  "B",
+  "B#"
+];
+var ScaleType = /* @__PURE__ */ ((ScaleType2) => {
+  ScaleType2["Major"] = "Major";
+  ScaleType2["NaturalMinor"] = "Natural Minor";
+  ScaleType2["HarmonicMinor"] = "Harmonic Minor";
+  ScaleType2["Ionian"] = "Ionian";
+  ScaleType2["Dorian"] = "Dorian";
+  ScaleType2["Phrygian"] = "Phrygian";
+  ScaleType2["Lydian"] = "Lydian";
+  ScaleType2["Mixolydian"] = "Mixolydian";
+  ScaleType2["Aeolian"] = "Aeolian";
+  ScaleType2["Locrian"] = "Locrian";
+  ScaleType2["MajorPentatonic"] = "Major Pentatonic";
+  ScaleType2["MinorPentatonic"] = "Minor Pentatonic";
+  ScaleType2["MajorHexatonicBlues"] = "Major Hexatonic Blues";
+  ScaleType2["MinorHexatonicBlues"] = "Minor Hexatonic Blues";
+  ScaleType2["HeptatonicBlues"] = "Heptatonic Blues";
+  return ScaleType2;
+})(ScaleType || {});
+function getMode(scaleType) {
+  switch (scaleType) {
+    case "Major" /* Major */:
+      return 1;
+    case "Natural Minor" /* NaturalMinor */:
+      return 6;
+    case "Harmonic Minor" /* HarmonicMinor */:
+      return 6;
+    case "Ionian" /* Ionian */:
+      return 1;
+    case "Dorian" /* Dorian */:
+      return 2;
+    case "Phrygian" /* Phrygian */:
+      return 3;
+    case "Lydian" /* Lydian */:
+      return 4;
+    case "Mixolydian" /* Mixolydian */:
+      return 5;
+    case "Aeolian" /* Aeolian */:
+      return 6;
+    case "Locrian" /* Locrian */:
+      return 7;
+    case "Major Pentatonic" /* MajorPentatonic */:
+      return 1;
+    case "Minor Pentatonic" /* MinorPentatonic */:
+      return 6;
+    case "Major Hexatonic Blues" /* MajorHexatonicBlues */:
+      return 1;
+    case "Minor Hexatonic Blues" /* MinorHexatonicBlues */:
+      return 6;
+    case "Heptatonic Blues" /* HeptatonicBlues */:
+      return 1;
+    default:
+      throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: ${scaleType}`);
+  }
+}
+var Scale = class extends KeySignature {
+  constructor(tonic, scaleType) {
+    super(tonic, getMode(scaleType));
+    this.tonic = tonic;
+    this.scaleType = scaleType;
+    __publicField(this, "scaleDegrees");
+    __publicField(this, "scaleNotes");
+    __publicField(this, "chromaticClassDegree");
+    __publicField(this, "preferredChromaticNoteCache", /* @__PURE__ */ new Map());
+    switch (scaleType) {
+      case "Harmonic Minor" /* HarmonicMinor */:
+        this.scaleDegrees = [1, 2, 3, 4, 5, 6, "#7"];
+        break;
+      case "Major Pentatonic" /* MajorPentatonic */:
+        this.scaleDegrees = [1, 2, 3, 5, 6];
+        break;
+      case "Minor Pentatonic" /* MinorPentatonic */:
+        this.scaleDegrees = [1, 3, 4, 5, 7];
+        break;
+      case "Major Hexatonic Blues" /* MajorHexatonicBlues */:
+        this.scaleDegrees = [1, 2, "b3", 3, 5, 6];
+        break;
+      case "Minor Hexatonic Blues" /* MinorHexatonicBlues */:
+        this.scaleDegrees = [1, 3, 4, "b5", 5, 7];
+        break;
+      case "Heptatonic Blues" /* HeptatonicBlues */:
+        this.scaleDegrees = [1, 2, "b3", 4, "b5", 6, "b7"];
+        break;
+      default:
+        this.scaleDegrees = [1, 2, 3, 4, 5, 6, 7];
+        break;
+    }
+    this.scaleNotes = this.scaleDegrees.map((d) => this.getNoteByDegree(d));
+    this.chromaticClassDegree = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].map((chromaticClass) => {
+      let id = this.scaleNotes.findIndex((scaleNote) => scaleNote.chromaticClass === chromaticClass);
+      return id >= 0 ? this.scaleDegrees[id] : void 0;
+    });
+  }
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.getScaleName() === b.getScaleName();
+    }
+  }
+  getScaleName(symbolSet) {
+    switch (symbolSet) {
+      case 1 /* Unicode */:
+        return Note.getScientificNoteName(this.tonic, symbolSet) + " " + this.scaleType;
+      default:
+        return this.tonic + " " + this.scaleType;
+    }
+  }
+  getScaleNotes(bottomNote, numOctaves) {
+    if (!Utils5.Is.isIntegerGte(numOctaves, 1)) {
+      throw new MusicError5(MusicErrorType5.Scale, `Invalid numOctaves: ${numOctaves}`);
+    }
+    let scaleNoteList = [];
+    for (let o = 1; o <= numOctaves; o++) {
+      scaleNoteList = [...scaleNoteList, ...this.scaleNotes];
+    }
+    scaleNoteList.push(this.scaleNotes[0]);
+    let diatonicId = Note.getNote(bottomNote).diatonicId;
+    return scaleNoteList.map((note) => {
+      diatonicId = Note.findNextDiatonicIdAbove(note.diatonicId, diatonicId, false);
+      return new Note(diatonicId, note.accidental);
+    });
+  }
+  getScaleOverview() {
+    return this.getScaleNotes("C4", 1).map((note) => note.formatOmitOctave(1 /* Unicode */)).join(" - ");
+  }
+  getScaleSteps() {
+    let chromaticIds = this.getScaleNotes("C4", 1).map((note) => note.chromaticId);
+    let steps = [];
+    for (let i = 0; i < chromaticIds.length - 1; i++) {
+      steps.push(Utils5.Math.mod(chromaticIds[i + 1] - chromaticIds[i], 12));
+    }
+    return steps;
+  }
+  getScaleStringSteps() {
+    return this.getScaleSteps().map((step) => step === 1 ? "H" : step === 2 ? "W" : step.toString() + "H");
+  }
+  isScaleNote(note) {
+    return this.chromaticClassDegree[note.chromaticClass] !== void 0;
+  }
+  isScaleRootNote(note) {
+    return String(this.chromaticClassDegree[note.chromaticClass]) === "1";
+  }
+  getIntervalFromRootNote(note) {
+    let rootNote = this.getScaleNotes("C0", 1)[0];
+    while (note.chromaticId >= rootNote.chromaticId + 12) {
+      note = new Note(note.diatonicClass, note.accidental, note.octave - 1);
+    }
+    if (note.chromaticId < rootNote.chromaticId) {
+      throw new MusicError5(MusicErrorType5.Scale, `Note is below rootNote.`);
+    }
+    let interval = Interval.get(rootNote, note);
+    if (interval === void 0) {
+      throw new MusicError5(MusicErrorType5.Scale, `Interval is undefined.`);
+    } else {
+      return interval;
+    }
+  }
+  getPreferredChromaticNote(chromaticId) {
+    Note.validateChromaticId(chromaticId);
+    let note = this.preferredChromaticNoteCache.get(chromaticId);
+    if (note) {
+      return note;
+    }
+    let octave = Note.getOctaveFromChromaticId(chromaticId);
+    let scaleNotes = this.scaleNotes.map((accNote) => {
+      if (accNote.noteLetter === "C" && accNote.accidental < 0) {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave + 1);
+      } else if (accNote.noteLetter === "B" && accNote.accidental > 0) {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave - 1);
+      } else {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave);
+      }
+    });
+    note = scaleNotes.find((note2) => Note.getChromaticClass(chromaticId) === note2.chromaticClass);
+    if (note) {
+      this.preferredChromaticNoteCache.set(chromaticId, note);
+      return note;
+    }
+    let diatonicIdMid = getNaturalDiatonicId(chromaticId);
+    let diatonicIdStart = diatonicIdMid - 2;
+    let diatonicIdEnd = diatonicIdMid + 2;
+    let preferFlat = this.getAccidentalType() === 1 /* Flats */;
+    let preferredAccs = preferFlat ? [0, -1, 1, -2, 2] : [0, 1, -1, 2, -2];
+    for (let ai = 0; ai < preferredAccs.length; ai++) {
+      let acc = preferredAccs[ai];
+      for (let diatonicId = Math.max(0, diatonicIdStart); diatonicId <= diatonicIdEnd; diatonicId++) {
+        note = new Note(diatonicId, acc);
+        if (chromaticId === note.chromaticId) {
+          this.preferredChromaticNoteCache.set(chromaticId, note);
+          return note;
+        }
+      }
+    }
+    note = Note.getChromaticNote(chromaticId);
+    this.preferredChromaticNoteCache.set(chromaticId, note);
+    return note;
+  }
+};
+var ScaleFactory = class {
+  constructor(type) {
+    this.type = type;
+    __publicField(this, "tonicList", []);
+    __publicField(this, "scaleMap", /* @__PURE__ */ new Map());
+    let naturalScales = [];
+    let sharpScales = [];
+    let flatScales = [];
+    FullTonicList.forEach((tonic) => {
+      try {
+        let scale = new Scale(tonic, this.type);
+        switch (scale.getAccidentalType()) {
+          case 0 /* Natural */:
+            naturalScales.push(scale);
+            break;
+          case 2 /* Sharps */:
+            if (tonic.endsWith("b")) {
+              return;
+            } else {
+              sharpScales.push(scale);
+              break;
+            }
+          case 1 /* Flats */:
+            if (tonic.endsWith("#")) {
+              return;
+            } else {
+              flatScales.push(scale);
+              break;
+            }
+        }
+        this.scaleMap.set(tonic, scale);
+      } catch (err) {
+      }
+    });
+    if (naturalScales.length === 0) {
+      throw new MusicError5(MusicErrorType5.Scale, `Expected natural scale.`);
+    }
+    const SortByAccidentalCountFunc = (a, b) => a.getNumAccidentals() - b.getNumAccidentals();
+    this.tonicList = [
+      ...naturalScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic),
+      "- Sharps -",
+      ...sharpScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic),
+      "- Flats -",
+      ...flatScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic)
+    ];
+  }
+  getTonicList() {
+    return this.tonicList;
+  }
+  getDefaultTonic() {
+    return this.tonicList[0];
+  }
+  getType() {
+    return this.type;
+  }
+  getScale(tonic) {
+    let scale = this.scaleMap.get(tonic);
+    if (!scale) {
+      throw new MusicError5(MusicErrorType5.Scale, `Invalid scale: ${tonic} ${this.type}`);
+    } else {
+      return scale;
+    }
+  }
+  hasScale(tonic) {
+    return this.scaleMap.get(tonic) !== void 0;
+  }
+};
+var ScaleFactoryList = [
+  new ScaleFactory("Major" /* Major */),
+  new ScaleFactory("Natural Minor" /* NaturalMinor */),
+  new ScaleFactory("Harmonic Minor" /* HarmonicMinor */),
+  "- Modes -",
+  new ScaleFactory("Ionian" /* Ionian */),
+  new ScaleFactory("Dorian" /* Dorian */),
+  new ScaleFactory("Phrygian" /* Phrygian */),
+  new ScaleFactory("Lydian" /* Lydian */),
+  new ScaleFactory("Mixolydian" /* Mixolydian */),
+  new ScaleFactory("Aeolian" /* Aeolian */),
+  new ScaleFactory("Locrian" /* Locrian */),
+  "- Pentatonic -",
+  new ScaleFactory("Major Pentatonic" /* MajorPentatonic */),
+  new ScaleFactory("Minor Pentatonic" /* MinorPentatonic */),
+  "- Blues -",
+  new ScaleFactory("Major Hexatonic Blues" /* MajorHexatonicBlues */),
+  new ScaleFactory("Minor Hexatonic Blues" /* MinorHexatonicBlues */),
+  new ScaleFactory("Heptatonic Blues" /* HeptatonicBlues */)
+];
+function getScaleFactoryList() {
+  return ScaleFactoryList;
+}
+var ScaleFactoryMap = /* @__PURE__ */ new Map();
+ScaleFactoryList.forEach((factory) => {
+  if (factory instanceof ScaleFactory) {
+    ScaleFactoryMap.set(factory.getType(), factory);
+  }
+});
+function getScaleFactory(scaleType) {
+  let f = ScaleFactoryMap.get(scaleType);
+  if (!f) {
+    throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: ${scaleType}`);
+  } else {
+    return f;
+  }
+}
+function validateScaleType(scaleType) {
+  if (Utils5.Is.isEnumValue(scaleType, ScaleType)) {
+    return scaleType;
+  } else {
+    throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: ${scaleType}`);
+  }
+}
+function getScale(tonic, scaleType) {
+  return getScaleFactory(scaleType).getScale(tonic);
+}
+var DefaultScale = getScale("C", "Major" /* Major */);
+function getDefaultScale() {
+  return DefaultScale;
+}
+
+// src/theory/chord.ts
+import { MusicError as MusicError6, MusicErrorType as MusicErrorType6 } from "@tspro/web-music-score/core";
+var isEqualNote = (n1, n2) => n1.chromaticClass === n2.chromaticClass;
+var OkayRootNoteList = [
+  "C",
+  "C#",
+  "Db",
+  // Same id, first one always gets found
+  "D",
+  "Eb",
+  "E",
+  "F",
+  "F#",
+  "Gb",
+  "G",
+  "Ab",
+  "A",
+  "Bb",
+  "B",
+  "Cb"
+].map((noteName) => Note.getNote(noteName + "0"));
+var okayRootNoteCache = /* @__PURE__ */ new Map();
+function getOkayRootNote(wantedRootNote) {
+  let cacheKey = wantedRootNote.chromaticClass;
+  let rootNote = okayRootNoteCache.get(cacheKey);
+  if (!rootNote) {
+    rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
+    if (!rootNote) {
+      throw new MusicError6(MusicErrorType6.InvalidArg, `Invalid chord root note: ${wantedRootNote.formatOmitOctave(1 /* Unicode */)}`);
+    }
+    okayRootNoteCache.set(cacheKey, rootNote);
+  }
+  return rootNote;
+}
+function getChordNoteByDegree(chordRootNote, degree) {
+  let chordRootNoteStr = chordRootNote.formatOmitOctave(0 /* Ascii */);
+  let ks = getScale(chordRootNoteStr, "Major" /* Major */);
+  return ks.getNoteByDegree(degree);
+}
+function removeNoteDuplicates(notes) {
+  return Utils6.Arr.removeDuplicatesCmp(notes, isEqualNote);
+}
+var ChordInfoList = [
+  // Power chord
+  { name: "5", degrees: [1, 5] },
+  // Triads
+  { name: "", degrees: [1, 3, 5] },
+  { name: "m", degrees: [1, "b3", 5] },
+  { name: "dim", degrees: [1, "b3", "b5"] },
+  { name: "aug", degrees: [1, 3, "#5"] },
+  { name: "sus2", degrees: [1, 2, 5] },
+  { name: "sus4", degrees: [1, 4, 5] },
+  // Four-part chords
+  { name: "6", degrees: [1, 3, 5, 6] },
+  { name: "m6", degrees: [1, "b3", 5, 6] },
+  { name: "m(maj7)", degrees: [1, "b3", 5, 7] },
+  { name: "7", degrees: [1, 3, 5, "b7"] },
+  { name: "7\u266D5", degrees: [1, 3, "b5", "b7"] },
+  { name: "7\u266F5", degrees: [1, 3, "#5", "b7"] },
+  { name: "7sus2", degrees: [1, 2, 5, "b7"] },
+  { name: "7sus4", degrees: [1, 4, 5, "b7"] },
+  { name: "dim7", degrees: [1, "b3", "b5", "bb7"] },
+  { name: "maj7", degrees: [1, 3, 5, 7] },
+  { name: "maj7\u266D5", degrees: [1, 3, "b5", 7] },
+  { name: "maj7\u266F5", degrees: [1, 3, "#5", 7] },
+  { name: "m7", degrees: [1, "b3", 5, "b7"] },
+  { name: "m7\u266D5", degrees: [1, "b3", "b5", "b7"] },
+  { name: "m7\u266F5", degrees: [1, "b3", "#5", "b7"] },
+  // Five-part chords
+  { name: "9", degrees: [1, 3, 5, "b7", 9] },
+  { name: "m9", degrees: [1, "b3", 5, "b7", 9] },
+  { name: "7\u266F9", degrees: [1, 3, 5, "b7", "#9"] },
+  { name: "7\u266D9", degrees: [1, 3, 5, "b7", "b9"] },
+  // Six-part chords
+  { name: "11", degrees: [1, 3, 5, "b7", 9, 11] },
+  { name: "m11", degrees: [1, "b3", 5, "b7", 9, 11] },
+  // Seven-part chords
+  { name: "13", degrees: [1, 3, 5, "b7", 9, 11, 13] },
+  { name: "m13", degrees: [1, "b3", 5, "b7", 9, 11, 13] }
+];
+function canOmitDegree(chordInfo, degree) {
+  if (chordInfo.degrees.every((c) => c !== degree)) {
+    return true;
+  }
+  return chordInfo.degrees.length >= 4 && degree === 5 || // Four (and higher) part chord can exclude 5th degree
+  chordInfo.degrees.length >= 6 && degree === 9 || // Six (and higher) part chord can exclude 9th degree
+  chordInfo.degrees.length >= 7 && degree === 11;
+}
+var InvalidChordException = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.msg = msg;
+    this.name = "InvalidChordException";
+  }
+};
+var Chord = class _Chord {
+  constructor(chordInfo, chordNotes, rootNote, bassNote) {
+    this.chordInfo = chordInfo;
+    this.rootNote = rootNote;
+    __publicField(this, "name");
+    __publicField(this, "notes");
+    __publicField(this, "omitNotes");
+    __publicField(this, "slashBassNote");
+    this.name = chordInfo.name;
+    let notesLeft = chordNotes.slice();
+    let outOfChordBass = !notesLeft.some((note) => isEqualNote(note, bassNote));
+    if (outOfChordBass) {
+      notesLeft.push(bassNote);
+    }
+    this.notes = new Array(this.chordInfo.degrees.length);
+    this.omitNotes = new Array(this.chordInfo.degrees.length);
+    for (let i = 0; i < chordInfo.degrees.length; i++) {
+      let degree = chordInfo.degrees[i];
+      let degreeNote = this.notes[i] = getChordNoteByDegree(this.rootNote, degree);
+      let noteIndex = notesLeft.findIndex((note) => isEqualNote(note, degreeNote));
+      if (noteIndex >= 0) {
+        this.omitNotes[i] = false;
+        notesLeft.splice(noteIndex, 1);
+      } else if (canOmitDegree(chordInfo, degree)) {
+        this.omitNotes[i] = true;
+      } else {
+        throw new InvalidChordException("Missing chord note!");
+      }
+      if (isEqualNote(bassNote, degreeNote)) {
+        bassNote = degreeNote;
+      }
+    }
+    if (notesLeft.length > 0) {
+      if (notesLeft.every((note) => isEqualNote(note, bassNote))) {
+        this.slashBassNote = bassNote;
+      } else {
+        throw new InvalidChordException("Got some extra notes that are not bass note!");
+      }
+    } else {
+      this.slashBassNote = isEqualNote(bassNote, this.rootNote) ? void 0 : bassNote;
+    }
+    if (chordInfo.name === "5" && this.slashBassNote) {
+      throw new InvalidChordException("Power chord no bass note allowed!");
+    }
+  }
+  static getChords(notes) {
+    let chords = [];
+    let chordNotes = Note.sort(notes);
+    let bassNote = chordNotes[0];
+    let uniqueNotes = removeNoteDuplicates(chordNotes);
+    for (let inversion = 0; inversion < uniqueNotes.length; inversion++) {
+      let rootNote = getOkayRootNote(uniqueNotes[inversion]);
+      ChordInfoList.forEach((chordInfo) => {
+        try {
+          let newChord = new _Chord(chordInfo, uniqueNotes, rootNote, bassNote);
+          let replaceIndex = chords.findIndex((chord) => chord.replaceWith(newChord));
+          if (replaceIndex >= 0) {
+            chords[replaceIndex] = newChord;
+          } else {
+            chords.push(newChord);
+          }
+        } catch (err) {
+          if (!(err instanceof InvalidChordException)) {
+            throw err;
+          }
+        }
+      });
+    }
+    return chords;
+  }
+  replaceWith(arg) {
+    if (arg.notes.length < this.notes.length) {
+      return false;
+    } else if (arg.slashBassNote && this.slashBassNote && !isEqualNote(arg.slashBassNote, this.slashBassNote) || arg.slashBassNote && !this.slashBassNote || !arg.slashBassNote && this.slashBassNote) {
+      return false;
+    }
+    for (let i = 0; i < this.notes.length; i++) {
+      if (!isEqualNote(arg.notes[i], this.notes[i]) || arg.omitNotes[i] !== this.omitNotes[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * @returns Chord name e.g. "C/B"
+   */
+  toString() {
+    let symbolSet = 1 /* Unicode */;
+    let rootNoteStr = this.rootNote.formatOmitOctave(symbolSet);
+    let slashBassStr = this.slashBassNote ? "/" + this.slashBassNote.formatOmitOctave(symbolSet) : "";
+    return rootNoteStr + this.name + slashBassStr;
+  }
+  /**
+   * @returns Degree notation string, e.g. "E - 1(C) - 3(E) - 5(G)"
+   */
+  getDegreeNotationString() {
+    let symbolSet = 1 /* Unicode */;
+    let bassNoteStr = this.slashBassNote ? this.slashBassNote.formatOmitOctave(symbolSet) + " - " : "";
+    let degreeNoteStr = this.omitNotes.map((omitNote, i) => {
+      return this.getDegreeStr(i) + "(" + (omitNote ? "-" : this.getNoteStr(i)) + ")";
+    }).join(" - ");
+    return bassNoteStr + degreeNoteStr;
+  }
+  /**
+   * @returns Omitted degrees string e.g. "Omits 5(G), 9(D)"
+   */
+  getOmittedDegreesString() {
+    let omittedStrList = this.omitNotes.map((omit, i) => {
+      return omit ? this.getDegreeStr(i) + "(" + this.getNoteStr(i) + ")" : void 0;
+    }).filter((str) => str !== void 0);
+    return omittedStrList.length > 0 ? "Omits " + omittedStrList.join(", ") : "";
+  }
+  /**
+   * @param i - Degree index
+   * @returns Degree string for given degree index, e.g. "3"
+   */
+  getDegreeStr(i) {
+    return Note.replaceAccidentalSymbols("" + this.chordInfo.degrees[i], 1 /* Unicode */);
+  }
+  /**
+   * @param i - Degree index
+   * @returns Note string for given degree index, e.g. "E"
+   */
+  getNoteStr(i) {
+    return this.notes[i].formatOmitOctave(1 /* Unicode */);
+  }
+};
+
+// src/theory/guitar.ts
+import { Utils as Utils7, LRUCache } from "@tspro/ts-utils-lib";
+
+// src/theory/assets/tunings.json
+var tunings_default = {
+  list: [
+    {
+      name: "Standard",
+      strings: [
+        "E2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "B Standard",
+      strings: [
+        "B1",
+        "E2",
+        "A2",
+        "D3",
+        "F#3",
+        "B3"
+      ]
+    },
+    {
+      name: "C Standard",
+      strings: [
+        "C2",
+        "F2",
+        "A#2",
+        "D#3",
+        "G3",
+        "C4"
+      ]
+    },
+    {
+      name: "D Modal",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "D Standard",
+      strings: [
+        "D2",
+        "G2",
+        "C3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "D# Standard",
+      strings: [
+        "D#2",
+        "G#2",
+        "C#3",
+        "F#3",
+        "A#3",
+        "D#4"
+      ]
+    },
+    {
+      name: "Double Drop D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "D4"
+      ]
+    },
+    {
+      name: "Drop B",
+      strings: [
+        "B1",
+        "F#2",
+        "B2",
+        "E3",
+        "G#3",
+        "C#4"
+      ]
+    },
+    {
+      name: "Drop C",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Drop D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Low C",
+      strings: [
+        "C2",
+        "G2",
+        "D3",
+        "G3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "New Standard",
+      strings: [
+        "C2",
+        "G2",
+        "D3",
+        "A3",
+        "E4",
+        "G4"
+      ]
+    },
+    {
+      name: "Open A",
+      strings: [
+        "E2",
+        "A2",
+        "C#3",
+        "E3",
+        "A3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open A Minor",
+      strings: [
+        "E2",
+        "A2",
+        "E3",
+        "A3",
+        "C4",
+        "E4"
+      ]
+    },
+    {
+      name: "Open C",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "G3",
+        "C4",
+        "E4"
+      ]
+    },
+    {
+      name: "Open C Minor",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "G3",
+        "C4",
+        "D#4"
+      ]
+    },
+    {
+      name: "Open D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "F#3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open D Minor",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open E",
+      strings: [
+        "E2",
+        "B2",
+        "E3",
+        "G#3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open E Minor",
+      strings: [
+        "E2",
+        "B2",
+        "E3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open G",
+      strings: [
+        "D2",
+        "G2",
+        "D3",
+        "G3",
+        "B3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open G Minor",
+      strings: [
+        "D2",
+        "G2",
+        "D3",
+        "G3",
+        "A#3",
+        "D4"
+      ]
+    }
+  ]
+};
+
+// src/theory/guitar.ts
+import { MusicError as MusicError7, MusicErrorType as MusicErrorType7 } from "@tspro/web-music-score/core";
+var Handedness = /* @__PURE__ */ ((Handedness2) => {
+  Handedness2[Handedness2["RightHanded"] = 0] = "RightHanded";
+  Handedness2[Handedness2["LeftHanded"] = 1] = "LeftHanded";
+  return Handedness2;
+})(Handedness || {});
+var DefaultHandedness = 0 /* RightHanded */;
+function validateHandedness(h) {
+  if (!Utils7.Is.isEnumValue(h, Handedness)) {
+    throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid handedness: ${h}`);
+  } else {
+    return h;
+  }
+}
+var TuningNameList = tunings_default.list.map((data) => data.name);
+var DefaultTuningName = TuningNameList[0];
+function validateTuningName(tuningName) {
+  if (TuningNameList.indexOf(tuningName) < 0) {
+    throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid tuning name: ${tuningName}`);
+  } else {
+    return tuningName;
+  }
+}
+var TuningStringsCache = new LRUCache(100);
+function getTuningStrings(tuningName) {
+  let tuningStrings = TuningStringsCache.get(tuningName);
+  if (!tuningStrings) {
+    let tuningData = tunings_default.list.find((data) => data.name === tuningName);
+    if (!tuningData) {
+      throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid tuningName: ${tuningName}`);
+    }
+    tuningStrings = tuningData.strings.slice().reverse().map((noteName) => Note.getNote(noteName));
+    if (!Utils7.Is.isIntegerEq(tuningStrings.length, 6)) {
+      throw new MusicError7(MusicErrorType7.Unknown, `Tuning has ${tuningStrings.length} strings.`);
+    }
+    TuningStringsCache.set(tuningName, tuningStrings);
+  }
+  return tuningStrings;
+}
+
+// src/theory/time-signature.ts
+import { Utils as Utils9 } from "@tspro/ts-utils-lib";
+
+// src/theory/rhythm.ts
+import { Utils as Utils8 } from "@tspro/ts-utils-lib";
+import { MusicError as MusicError8, MusicErrorType as MusicErrorType8 } from "@tspro/web-music-score/core";
+var NoteLength = /* @__PURE__ */ ((NoteLength3) => {
+  NoteLength3[NoteLength3["Whole"] = 192] = "Whole";
+  NoteLength3[NoteLength3["Half"] = 96] = "Half";
+  NoteLength3[NoteLength3["Quarter"] = 48] = "Quarter";
+  NoteLength3[NoteLength3["Eighth"] = 24] = "Eighth";
+  NoteLength3[NoteLength3["Sixteenth"] = 12] = "Sixteenth";
+  NoteLength3[NoteLength3["ThirtySecond"] = 6] = "ThirtySecond";
+  NoteLength3[NoteLength3["SixtyFourth"] = 3] = "SixtyFourth";
+  return NoteLength3;
+})(NoteLength || {});
+var MaxNoteLength = 192 /* Whole */;
+var MinNoteLength = 3 /* SixtyFourth */;
+var FlagCountMap = /* @__PURE__ */ new Map([
+  [192 /* Whole */, 0],
+  [96 /* Half */, 0],
+  [48 /* Quarter */, 0],
+  [24 /* Eighth */, 1],
+  [12 /* Sixteenth */, 2],
+  [6 /* ThirtySecond */, 3],
+  [3 /* SixtyFourth */, 4]
+]);
+var NoteSymbolMap = /* @__PURE__ */ new Map([
+  [192 /* Whole */, "\u{1D15D}"],
+  [96 /* Half */, "\u{1D15E}"],
+  [48 /* Quarter */, "\u{1D15F}"],
+  [24 /* Eighth */, "\u{1D160}"],
+  [12 /* Sixteenth */, "\u{1D161}"],
+  [6 /* ThirtySecond */, "\u{1D162}"],
+  [3 /* SixtyFourth */, "\u{1D163}"]
+]);
+function validateNoteLength(noteLength) {
+  if (!Utils8.Is.isEnumValue(noteLength, NoteLength)) {
+    throw new MusicError8(MusicErrorType8.InvalidArg, `Invalid noteLength: ${noteLength}`);
+  } else {
+    return noteLength;
+  }
+}
+var RhythmProps = class _RhythmProps {
+  constructor(noteLength, dotted, triplet) {
+    __publicField(this, "noteLength");
+    __publicField(this, "dotted");
+    __publicField(this, "triplet");
+    __publicField(this, "ticks");
+    __publicField(this, "flagCount");
+    var _a;
+    this.noteLength = validateNoteLength(noteLength);
+    this.dotted = dotted === true;
+    this.triplet = triplet === true;
+    this.ticks = this.noteLength;
+    this.flagCount = (_a = FlagCountMap.get(this.noteLength)) != null ? _a : 0;
+    if (this.dotted && this.triplet) {
+      throw new MusicError8(MusicErrorType8.Note, "Note cannot be both dotted and triplet!");
+    } else if (this.dotted && this.noteLength === MinNoteLength) {
+      throw new MusicError8(MusicErrorType8.Note, "Shortest note cannot be dotted!");
+    }
+    if (this.dotted) {
+      this.ticks += this.noteLength / 2;
+    }
+    if (this.triplet) {
+      this.ticks = this.ticks * 2 / 3;
+    }
+  }
+  static createFromNoteSize(noteSize) {
+    return new _RhythmProps(MaxNoteLength / noteSize);
+  }
+  canDot() {
+    return !this.dotted && this.noteLength !== MinNoteLength;
+  }
+  hasStem() {
+    return this.noteLength < 192 /* Whole */;
+  }
+  toString() {
+    return NoteSymbolMap.get(this.noteLength) + (this.dotted ? "." : "");
+  }
+};
+
+// src/theory/time-signature.ts
+import { MusicError as MusicError9, MusicErrorType as MusicErrorType9 } from "@tspro/web-music-score/core";
+var TimeSignature = class {
+  constructor(...args) {
+    __publicField(this, "beatCount");
+    __publicField(this, "beatSize");
+    /** Lengths in ticks */
+    __publicField(this, "beatLength");
+    __publicField(this, "measureTicks");
+    __publicField(this, "beamGroupCount");
+    __publicField(this, "beamGroupLength");
+    if (args.length === 1 && typeof args[0] === "string") {
+      let parts = args[0].split("/");
+      this.beatCount = +parts[0];
+      this.beatSize = +parts[1];
+    } else if (args.length === 2 && typeof args[0] === "number" && typeof args[1] === "number") {
+      this.beatCount = args[0];
+      this.beatSize = args[1];
+    } else {
+      throw new MusicError9(MusicErrorType9.Timesignature, `Invalid args: ${args}`);
+    }
+    if (!Utils9.Is.isIntegerGte(this.beatCount, 1)) {
+      throw new MusicError9(MusicErrorType9.Timesignature, `Invalid beatCount: ${this.beatCount}`);
+    } else if (!Utils9.Is.isIntegerGte(this.beatSize, 1)) {
+      throw new MusicError9(MusicErrorType9.Timesignature, `Invalid beatSize: ${this.beatSize}`);
+    }
+    let beatLengthValue = RhythmProps.createFromNoteSize(this.beatSize);
+    this.beatLength = beatLengthValue.noteLength;
+    this.measureTicks = this.beatCount * beatLengthValue.ticks;
+    if (this.is(2, 4) || this.is(3, 4) || this.is(4, 4)) {
+      this.beamGroupCount = this.beatCount;
+    } else if (this.is(6, 8) || this.is(9, 8)) {
+      this.beamGroupCount = this.beatCount / 3;
+    } else {
+      console.warn("Not necessarily an error, but unsupported time signature: " + this.toString());
+      this.beamGroupCount = 1;
+    }
+    this.beamGroupLength = this.measureTicks / this.beamGroupCount;
+    if (!Utils9.Is.isIntegerGte(this.beamGroupLength, 1)) {
+      throw new MusicError9(MusicErrorType9.Timesignature, `Invalid beamGroupLength: ${this.beamGroupLength}`);
+    }
+  }
+  is(beatCount, beatSize) {
+    return this.beatCount === beatCount && this.beatSize === beatSize;
+  }
+  toString() {
+    return this.beatCount + "/" + this.beatSize;
+  }
+};
+var defaultTimeSignature;
+function getDefaultTimeSignature() {
+  if (!defaultTimeSignature) {
+    defaultTimeSignature = new TimeSignature(4, 4);
+  }
+  return defaultTimeSignature;
+}
+
+// src/theory/tempo.ts
+var defaultTempo;
+function getDefaultTempo() {
+  if (!defaultTempo) {
+    defaultTempo = { beatsPerMinute: 120, options: { beatLength: 48 /* Quarter */, dotted: false } };
+  }
+  return defaultTempo;
+}
+function getTempoString(tempo) {
+  return new RhythmProps(tempo.options.beatLength, tempo.options.dotted).toString() + "=" + tempo.beatsPerMinute;
+}
+function alterTempoSpeed(tempo, speed) {
+  return {
+    beatsPerMinute: tempo.beatsPerMinute * speed,
+    options: { beatLength: tempo.options.beatLength, dotted: tempo.options.dotted }
+  };
+}
+
+// src/theory/index.ts
+import { init as initCore } from "@tspro/web-music-score/core";
+initCore();
+export {
+  AccidentalType,
+  Chord,
+  DefaultGuitarNoteLabel,
+  DefaultHandedness,
+  DefaultPitchNotation,
+  DefaultTuningName,
+  GuitarNoteLabel,
+  GuitarNoteLabelList,
+  Handedness,
+  Interval,
+  KeySignature,
+  MaxNoteLength,
+  MinNoteLength,
+  Mode,
+  Note,
+  NoteLength,
+  PitchNotation,
+  PitchNotationList,
+  RhythmProps,
+  Scale,
+  ScaleFactory,
+  ScaleType,
+  SymbolSet,
+  TimeSignature,
+  TuningNameList,
+  alterTempoSpeed,
+  getDefaultKeySignature,
+  getDefaultScale,
+  getDefaultTempo,
+  getDefaultTimeSignature,
+  getPitchNotationName,
+  getScale,
+  getScaleFactory,
+  getScaleFactoryList,
+  getTempoString,
+  getTuningStrings,
+  validateGuitarNoteLabel,
+  validateHandedness,
+  validateIntervalQuality,
+  validateNoteLength,
+  validatePitchNotation,
+  validateScaleType,
+  validateTuningName
+};
+//# sourceMappingURL=index.mjs.map