web-music-score 0.0.1 → 6.0.0-pre.1

package/dist/theory/index.mjs

@@ -0,0 +1,1986 @@
+/* WebMusicScore v6.0.0-pre.1 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+import {
+  NoteLength,
+  NoteLengthProps,
+  RhythmProps,
+  Tuplet,
+  isNoteLength,
+  isTupletRatio,
+  validateNoteLength,
+  validateTupletRatio
+} from "../chunk-GNT3ECDB.mjs";
+import {
+  IndexArray,
+  LRUCache,
+  SignedIndexArray,
+  UniMap,
+  guard_exports,
+  utils_exports
+} from "../chunk-X7BMJX7E.mjs";
+import {
+  __publicField
+} from "../chunk-A7C2G7OG.mjs";
+
+// src/theory/types.ts
+import { MusicError, MusicErrorType } from "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_exports.Enum.getEnumValues(PitchNotation);
+var DefaultPitchNotation = 0 /* Scientific */;
+function validatePitchNotation(pn) {
+  if (guard_exports.isEnumValue(pn, PitchNotation)) {
+    return pn;
+  } else {
+    throw new MusicError(MusicErrorType.InvalidArg, `Invalid pitchNotation: ${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_exports.Enum.getEnumValues(GuitarNoteLabel);
+function validateGuitarNoteLabel(label) {
+  if (guard_exports.isEnumValue(label, GuitarNoteLabel)) {
+    return label;
+  } else {
+    throw new MusicError(MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
+  }
+}
+
+// src/theory/note.ts
+import { MusicError as MusicError2, MusicErrorType as MusicErrorType2 } from "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) {
+    /** Diatonic class */
+    __publicField(this, "diatonicClass");
+    /** Accidental. */
+    __publicField(this, "accidental");
+    /** Octave. */
+    __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}`);
+    }
+  }
+  /** Diatonic id getter. */
+  get diatonicId() {
+    return _Note.getDiatonicIdInOctave(this.diatonicClass, this.octave);
+  }
+  /** Chromatic id getter. */
+  get chromaticId() {
+    return _Note.getChromaticIdInOctave(DiatonicToChromaticMap[this.diatonicClass] + this.accidental, this.octave);
+  }
+  /** Midi number getter (implemented same as chromatic id). */
+  get midiNumber() {
+    return this.chromaticId;
+  }
+  /** Chromatic class getter. */
+  get chromaticClass() {
+    return _Note.getChromaticClass(DiatonicToChromaticMap[this.diatonicClass] + this.accidental);
+  }
+  /** Note letter getter. */
+  get noteLetter() {
+    return NoteLetters[this.diatonicClass];
+  }
+  /**
+   * Format note to string presentation.
+   * @param pitchNotation - Pitchy notation.
+   * @param symbolSet - Symbol set.
+   * @returns - String presentation of note.
+   */
+  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;
+    }
+  }
+  /**
+   * Format note to string presentation without octave number.
+   * @param symbolSet - Symbol set.
+   * @returns - String presentation of note without octave number.
+   */
+  formatOmitOctave(symbolSet) {
+    let noteLetter = NoteLetters[this.diatonicClass];
+    let accidental = _Note.getAccidentalSymbol(this.accidental, symbolSet);
+    return noteLetter + accidental;
+  }
+  /**
+   * Get note.
+   * @param noteName - Note name (e.g. "C4").
+   * @returns - Note.
+   */
+  static getNote(noteName) {
+    return this.noteCache.getOrCreate(noteName, () => {
+      let p = _Note.parseNote(noteName);
+      if (!p)
+        throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}".`);
+      if (p.octave === void 0)
+        throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}" (missing octave).`);
+      return new _Note(p.noteLetter, p.accidental, p.octave);
+    });
+  }
+  /**
+   * Test if given note name valid.
+   * @param noteName - Note name.
+   * @returns - True/false.
+   */
+  static isNote(noteName) {
+    let p = _Note.parseNote(noteName);
+    return p !== void 0 && p.octave !== void 0;
+  }
+  /**
+   * Validate given note name.
+   * @param noteName - Note name.
+   * @returns - True or throws.
+   */
+  static validateNote(noteName) {
+    if (this.isNote(noteName)) return true;
+    throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}"`);
+  }
+  /**
+   * Get chromatic note. There are number of alternatives, this function uses simple logic to choose one.
+   * @param chromaticId - Chromatic id.
+   * @returns - Note.
+   */
+  static getChromaticNote(chromaticId) {
+    return this.chromaticNoteCache.getOrCreate(chromaticId, () => {
+      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);
+      return _Note.getNote(noteName);
+    });
+  }
+  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}`);
+    }
+  }
+  /**
+   * Get octave from diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Octave.
+   */
+  static getOctaveFromDiatonicId(diatonicId) {
+    return Math.floor((diatonicId - C0_diatonicId) / 7);
+  }
+  /**
+   * Get diatonic id in given octave (transposes diatonic id to given octave).
+   * @param diatonicId - Original diatonic id.
+   * @param octave - Octave.
+   * @returns - Transposed diatonic id.
+   */
+  static getDiatonicIdInOctave(diatonicId, octave) {
+    return _Note.getDiatonicClass(diatonicId) + octave * 7 + C0_diatonicId;
+  }
+  /**
+   * Get chromatic class from chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Chromatic class.
+   */
+  static getChromaticClass(chromaticId) {
+    return mod(chromaticId, 12);
+  }
+  /**
+   * Get octave from chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Octave.
+   */
+  static getOctaveFromChromaticId(chromaticId) {
+    return Math.floor((chromaticId - C0_chromaticId) / 12);
+  }
+  /**
+   * Get chromatic id in given octave (transposes chromatic id to given octave).
+   * @param chromaticId - Original chromatic id.
+   * @param octave - Octave.
+   * @returns - Transpose chromatic id.
+   */
+  static getChromaticIdInOctave(chromaticId, octave) {
+    return _Note.getChromaticClass(chromaticId) + octave * 12 + C0_chromaticId;
+  }
+  /**
+   * Test if given two notes are equal.
+   * @param a - Note a.
+   * @param b - Note b.
+   * @returns - True/false.
+   */
+  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;
+    }
+  }
+  /**
+   * Replace accidental symbols in given string to givn symbol set (ascii/unicode).
+   * @param str - String to replace.
+   * @param symbolSet - Symbol set.
+   * @returns - String with updated accidental symbols.
+   */
+  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");
+    }
+  }
+  /**
+   * Test if given string is valid note name.
+   * @param noteName - Note name to validate.
+   * @returns - True/false.
+   */
+  static isValidNoteName(noteName) {
+    return NoteNameRegex.test(noteName);
+  }
+  /**
+   * Parse note name string to note props.
+   * @param noteName - Note name to parse.
+   * @returns - Parsed note props or undefined if parsing error.
+   */
+  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 };
+  }
+  /**
+   * Get scientific note name from given note name.
+   * @param noteName - Note name.
+   * @param symbolSet - Symbol set (ascii/unicode) for scientific note name.
+   * @returns - Scientific note name.
+   */
+  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 : "");
+  }
+  /**
+   * Get symbol of given accidental in given symbol set (ascii/unicide).
+   * @param accidental - Accidental.
+   * @param symbolsSet - Symbol set.
+   * @returns - Accidental symbol or undefined (invalid accidental).
+   */
+  static getAccidentalSymbol(accidental, symbolsSet) {
+    return symbolsSet === 1 /* Unicode */ ? AccidentalUnicodeSymbolMap.get(accidental) : AccidentalAsciiSymbolMap.get(accidental);
+  }
+  /**
+   * Get accidental value from given accidental symbol.
+   * @param accidentalSymbol - Accidental symbol (e.g. "#").
+   * @returns - Accidental vlaue.
+   */
+  static getAccidental(accidentalSymbol) {
+    let accidental = AccidentalMap.get(accidentalSymbol);
+    if (accidental === void 0) {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid accidental: ${accidentalSymbol}`);
+    }
+    return accidental;
+  }
+  /**
+   * Get note letter from given diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Note letter.
+   */
+  static getNoteLetter(diatonicId) {
+    return NoteLetters[_Note.getDiatonicClass(diatonicId)];
+  }
+  /**
+   * Find next lowest possible diatonic id that is above given bottom level.
+   * @param diatonicId - Diatonic id to begin with.
+   * @param bottomDiatonicId - Bottom diatonic id.
+   * @param addOctaveIfEqual - If true then add one octave if diatonic id would equal to bottom diatonic id.
+   * @returns - Diatonic id.
+   */
+  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);
+  }
+  /**
+   * Validate if given argument is diatonic id.
+   * @param diatonicId - Diatonic id to validate.
+   * @returns - Valid diatonic id or throws.
+   */
+  static validateDiatonicId(diatonicId) {
+    if (guard_exports.isInteger(diatonicId)) {
+      return diatonicId;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicId: ${diatonicId}`);
+    }
+  }
+  /**
+   * Validate if given argument is diatonic class.
+   * @param diatonicClass - Diatonic class to validate.
+   * @returns - Valid diatonic class or throws.
+   */
+  static validateDiatonicClass(diatonicClass) {
+    if (guard_exports.isIntegerBetween(diatonicClass, 0, 6)) {
+      return diatonicClass;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicClass: ${diatonicClass}`);
+    }
+  }
+  /**
+   * Validate if given argument is chromatic id.
+   * @param chromaticId - Chromatic id to validate.
+   * @returns - Valid chromatic id, or throws.
+   */
+  static validateChromaticId(chromaticId) {
+    if (guard_exports.isInteger(chromaticId)) {
+      return chromaticId;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticId: ${chromaticId}`);
+    }
+  }
+  /**
+   * Validate if given argument is chromatic class.
+   * @param chromaticClass - Chromatic class to validate.
+   * @returns - Valid chromatic class, or throws.
+   */
+  static validatechromaticClass(chromaticClass) {
+    if (guard_exports.isIntegerBetween(chromaticClass, 0, 11)) {
+      return chromaticClass;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticClass: ${chromaticClass}`);
+    }
+  }
+  /**
+   * Validate if given argument if note letter.
+   * @param noteLetter - Note letter to validate.
+   * @returns - Valid note letter or throws.
+   */
+  static validateNoteLetter(noteLetter) {
+    if (NoteLetters.some((n) => n === noteLetter)) {
+      return noteLetter;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid note: ${noteLetter}`);
+    }
+  }
+  /**
+   * Validate if given argument is octave.
+   * @param octave - Octave to validate.
+   * @returns - Valid octave or throws.
+   */
+  static validateOctave(octave) {
+    if (guard_exports.isInteger(octave)) {
+      return octave;
+    } else {
+      throw new MusicError2(MusicErrorType2.Note, `Invalid octave: ${octave}`);
+    }
+  }
+  /**
+   * Validate if given argument is valid accidental.
+   * @param acc - Accidental to validate.
+   * @returns - Valid accidental or thorws.
+   */
+  static validateAccidental(acc) {
+    if (guard_exports.isIntegerBetween(acc, -2, 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;
+  }
+  /**
+   * Function to compare two notes using diatonic id and accidental properties of notes.
+   * @param a - Note a.
+   * @param b - Note b.
+   * @returns - -1, 0 or 1.
+   */
+  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, "noteCache", new UniMap());
+__publicField(_Note, "chromaticNoteCache", new UniMap());
+var Note = _Note;
+
+// src/theory/key-signature.ts
+import { MusicError as MusicError3, MusicErrorType as MusicErrorType3 } from "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 (!guard_exports.isInteger(acc) || acc < -2 || acc > 2 || !guard_exports.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 (!guard_exports.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;
+  }
+  /**
+   * Get accidental type sharps, flats, or natural (without accidentals).
+   * @returns - Accidental type.
+   */
+  getAccidentalType() {
+    if (this.orderedAccidentedNotes.length === 0) {
+      return 0 /* Natural */;
+    } else if (this.orderedAccidentedNotes[0].accidental < 0) {
+      return 1 /* Flats */;
+    } else {
+      return 2 /* Sharps */;
+    }
+  }
+  /**
+   * Get natural scale notes of this key signature, natural scale has 7 steps (e.g. Major scale: W, W, H, W, W, W, H).
+   * @returns - Array of notes.
+   */
+  getNaturalScaleNotes() {
+    return this.naturalScaleNotes;
+  }
+  /**
+   * Get accidental for given diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Accidental -2, -1, 0, 1 or 2.
+   */
+  getAccidental(diatonicId) {
+    var _a;
+    return (_a = this.accidentalByDiatonicClass[Note.getDiatonicClass(diatonicId)]) != null ? _a : 0;
+  }
+  /**
+   * Get number of accidentals this key signature has.
+   * @returns - Number of accidentals.
+   */
+  getNumAccidentals() {
+    return this.orderedAccidentedNotes.length;
+  }
+  /**
+   * Get accidental notes in correct order.
+   * @returns - Array of accidental notes.
+   */
+  getOrderedAccidentalNotes() {
+    return this.orderedAccidentedNotes;
+  }
+  /**
+   * Get note of key signature by degree value.
+   * @param degree - Degree number in range [1, 7] or string e.g "b5" or "#4".
+   * @returns - Note.
+   */
+  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);
+    }
+  }
+  /**
+   * Test equality of given key signatures.
+   * @param a - Key signature a.
+   * @param b - Key signature b.
+   * @returns - True/false.
+   */
+  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 { MusicError as MusicError4, MusicErrorType as MusicErrorType4 } from "web-music-score/core";
+var IntervalQualityAbbrMap = new UniMap([
+  ["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 (!guard_exports.isIntegerGte(q, 1)) {
+    throw new MusicError4(MusicErrorType4.InvalidArg, `Invalid interval quantity: ${q}`);
+  } else {
+    return utils_exports.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;
+    /** Interval direction. */
+    __publicField(this, "direction");
+    /** Number of semitones. */
+    __publicField(this, "semitones");
+    /** Interval quantity. */
+    __publicField(this, "quantity");
+    /** Interval quality. */
+    __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");
+    }
+  }
+  /**
+   * Get interval between given two notes.
+   * @param note1 - First note.
+   * @param note2 - Second note.
+   * @returns - Interval if valid, or undefined.
+   */
+  static get(note1, note2) {
+    try {
+      return new _Interval(note1, note2);
+    } catch (err) {
+      if (err instanceof InvalidIntervalException) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Get string presentation of interval (e.g. "Descending Major 2").
+   * @returns - Interval string.
+   */
+  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;
+  }
+  /**
+   * Get abbrevated string presentation of interval (e.g. "↓M2").
+   * @returns - Interval abbrevated string.
+   */
+  toAbbrString() {
+    let direction = this.direction === "Descending" ? "\u2193" : "";
+    let quality = IntervalQualityAbbrMap.getOrDefault(this.quality, "?");
+    let quantity = this.quantity;
+    return direction + quality + quantity;
+  }
+};
+
+// src/theory/scale.ts
+import { MusicError as MusicError5, MusicErrorType as MusicErrorType5 } from "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 {
+  /**
+   * Create nev scale object instance.
+   * @param tonic - Tonic (e.g. "C" in "C Major").
+   * @param scaleType - Scale typo ("e.g. "Major" in "C Major").
+   */
+  constructor(tonic, scaleType) {
+    super(tonic, getMode(scaleType));
+    this.tonic = tonic;
+    this.scaleType = scaleType;
+    /** Degrees of scale notes. */
+    __publicField(this, "scaleDegrees");
+    /** Scale notes. */
+    __publicField(this, "scaleNotes");
+    /** Degrees (or undefined) of chromatic classes. */
+    __publicField(this, "chromaticClassDegree");
+    __publicField(this, "preferredChromaticIdNoteCache", new SignedIndexArray());
+    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;
+    });
+  }
+  /**
+   * Compare if two scales equals.
+   * @param a - Scale a.
+   * @param b - Scale b.
+   * @returns - Boolean equality of given scales.
+   */
+  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();
+    }
+  }
+  /**
+   * Get scale name.
+   * @param symbolSet - Symbol set to format scale name in ascii or unicode.
+   * @returns - Scale name string.
+   */
+  getScaleName(symbolSet) {
+    switch (symbolSet) {
+      case 1 /* Unicode */:
+        return Note.getScientificNoteName(this.tonic, symbolSet) + " " + this.scaleType;
+      default:
+        return this.tonic + " " + this.scaleType;
+    }
+  }
+  /**
+   * Get scale notes.
+   * @param bottomNote - Computed scale notes begin no lower than this note.
+   * @param numOctaves - How many octaves?
+   * @returns - Array of scale notes.
+   */
+  getScaleNotes(bottomNote, numOctaves) {
+    if (!guard_exports.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);
+    });
+  }
+  /**
+   * Get scale overview (e.g. "C - D - E - F - G - A - B" for "C Major" scale).
+   * @returns - Scale overview string.
+   */
+  getScaleOverview() {
+    return this.getScaleNotes("C4", 1).map((note) => note.formatOmitOctave(1 /* Unicode */)).join(" - ");
+  }
+  /**
+   * Get scale steps, array of 1 (half step) and 2 (whole step), (e.g. [2, 2, 1, 2, 2, 2, 1] for Major scale).
+   * @returns - Array of scale steps.
+   */
+  getScaleSteps() {
+    let chromaticIds = this.getScaleNotes("C4", 1).map((note) => note.chromaticId);
+    let steps = [];
+    for (let i = 0; i < chromaticIds.length - 1; i++) {
+      steps.push(utils_exports.Math.mod(chromaticIds[i + 1] - chromaticIds[i], 12));
+    }
+    return steps;
+  }
+  /**
+   * Get scale steps string presentation, array of "H" (half step) and "W" (whole step), (e.g. ["W", "W", "H", "W", "W", "W", "H"] for Major scale).
+   * @returns - Array of scale steps string presentation.
+   */
+  getScaleStringSteps() {
+    return this.getScaleSteps().map((step) => step === 1 ? "H" : step === 2 ? "W" : step.toString() + "H");
+  }
+  /**
+   * Test if given note is scale note.
+   * @param note - Note to test.
+   * @returns - True/false.
+   */
+  isScaleNote(note) {
+    return this.chromaticClassDegree[note.chromaticClass] !== void 0;
+  }
+  /**
+   * Test if given note is scale root note.
+   * @param note - Note to test.
+   * @returns - True/false.
+   */
+  isScaleRootNote(note) {
+    return String(this.chromaticClassDegree[note.chromaticClass]) === "1";
+  }
+  /**
+   * Get interval value between scale root note and given note.
+   * @param note - Note.
+   * @returns - Interval.
+   */
+  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;
+    }
+  }
+  // Can it be negative case?
+  /**
+   * Get preferred chromatic note from given chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Note.
+   */
+  getPreferredChromaticNote(chromaticId) {
+    Note.validateChromaticId(chromaticId);
+    let note = this.preferredChromaticIdNoteCache.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.preferredChromaticIdNoteCache.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.preferredChromaticIdNoteCache.set(chromaticId, note);
+          return note;
+        }
+      }
+    }
+    note = Note.getChromaticNote(chromaticId);
+    this.preferredChromaticIdNoteCache.set(chromaticId, note);
+    return note;
+  }
+};
+var ScaleFactory = class {
+  /**
+   * Create new scale factory object instance.
+   * @param type - Scale type.
+   */
+  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)
+    ];
+  }
+  /**
+   * Get list of tonics (e.g. "C", "C#", ... for Major scale type).
+   * @returns - Array of tonics.
+   */
+  getTonicList() {
+    return this.tonicList;
+  }
+  /**
+   * Get default tonic.
+   * @returns - Default tonic.
+   */
+  getDefaultTonic() {
+    return this.tonicList[0];
+  }
+  /**
+   * Get scale type.
+   * @returns - SCale type.
+   */
+  getType() {
+    return this.type;
+  }
+  /**
+   * Get scale by given tonic.
+   * @param tonic - Tonic (e.g. "C").
+   * @returns - Scale.
+   */
+  getScale(tonic) {
+    let scale = this.scaleMap.get(tonic);
+    if (!scale) {
+      throw new MusicError5(MusicErrorType5.Scale, `Invalid scale: ${tonic} ${this.type}`);
+    } else {
+      return scale;
+    }
+  }
+  /**
+   * Test if this scale factory has scale for given tonic value.
+   * @param tonic - Tonic.
+   * @returns - True/false.
+   */
+  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 = new UniMap();
+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 (guard_exports.isEnumValue(scaleType, ScaleType)) {
+    return scaleType;
+  } else {
+    throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: "${scaleType}"`);
+  }
+}
+function getScale(arg0, arg1) {
+  let tonic;
+  let scaleType;
+  if (arg1 !== void 0) {
+    tonic = arg0;
+    scaleType = validateScaleType(arg1);
+  } else {
+    tonic = arg0.split(" ")[0];
+    scaleType = validateScaleType(arg0.substring(tonic.length + 1));
+  }
+  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 "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 = new IndexArray();
+function getOkayRootNote(wantedRootNote) {
+  return okayRootNoteCache.getOrCreate(wantedRootNote.chromaticClass, () => {
+    let rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
+    if (!rootNote) {
+      throw new MusicError6(MusicErrorType6.InvalidArg, `Invalid chord root note: ${wantedRootNote.formatOmitOctave(1 /* Unicode */)}`);
+    }
+    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 utils_exports.Arr.removeDuplicates(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;
+    /** Chord name. */
+    __publicField(this, "name");
+    /** Notes of this chord. */
+    __publicField(this, "notes");
+    /** Notes that are omitted in this chord (partial chord). */
+    __publicField(this, "omitNotes");
+    /** Bass note if not chord root note (e.g. "B" in "C/B"). */
+    __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!");
+    }
+  }
+  /**
+   * Get all chords that can be made up with given notes.
+   * @param notes - Array of notes.
+   * @returns - Array of chords.
+   */
+  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;
+  }
+  /**
+   * Get chord string presentation.
+   * @returns Chord string presentation (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;
+  }
+  /**
+   * Get degree notation string (e.g. "E - 1(C) - 3(E) - 5(G)").
+   * @returns Degree notation string.
+   */
+  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;
+  }
+  /**
+   * Get string presentation of omitted degrees (e.g. "Omits 5(G), 9(D)").
+   * @returns - String presentation of omitted degrees.
+   */
+  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(", ") : "";
+  }
+  /**
+   * Degree index for given degree index (e.g. "3").
+   * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+   * @returns Degree string.
+   */
+  getDegreeStr(i) {
+    return Note.replaceAccidentalSymbols("" + this.chordInfo.degrees[i], 1 /* Unicode */);
+  }
+  /**
+   * Get note name for given degree index (e.g. "E").
+   * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+   * @returns - Note name string.
+   */
+  getNoteStr(i) {
+    return this.notes[i].formatOmitOctave(1 /* Unicode */);
+  }
+};
+
+// 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 "web-music-score/core";
+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 (!guard_exports.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 { MusicError as MusicError8, MusicErrorType as MusicErrorType8 } from "web-music-score/core";
+var TimeSignatures = /* @__PURE__ */ ((TimeSignatures2) => {
+  TimeSignatures2["_2_4"] = "2/4";
+  TimeSignatures2["_3_4"] = "3/4";
+  TimeSignatures2["_4_4"] = "4/4";
+  TimeSignatures2["_3_8"] = "3/8";
+  TimeSignatures2["_5_8"] = "5/8";
+  TimeSignatures2["_6_8"] = "6/8";
+  TimeSignatures2["_7_8"] = "7/8";
+  TimeSignatures2["_9_8"] = "9/8";
+  TimeSignatures2["_12_8"] = "12/8";
+  return TimeSignatures2;
+})(TimeSignatures || {});
+var BeamGrouping = /* @__PURE__ */ ((BeamGrouping2) => {
+  BeamGrouping2["_2_3"] = "2-3";
+  BeamGrouping2["_3_2"] = "3-2";
+  BeamGrouping2["_2_2_3"] = "2-2-3";
+  BeamGrouping2["_3_2_2"] = "3-2-2";
+  return BeamGrouping2;
+})(BeamGrouping || {});
+var TimeSignature = class {
+  constructor(...args) {
+    /** Number of beats in measure, upper value (e.g. "3" in "3/4"). */
+    __publicField(this, "beatCount");
+    /** Beat size of time signature, lower value (e.g. "4" in "3/4"). */
+    __publicField(this, "beatSize");
+    /** Beat length. */
+    __publicField(this, "beatLength");
+    /** Number of ticks in measure. */
+    __publicField(this, "measureTicks");
+    /** Beam groups (e.g. [[2], [2]] or [[2, 2], [2, 2]] (first try as [[4], [4]])). */
+    __publicField(this, "beamGroupSizes", []);
+    let beamGrouping;
+    if (guard_exports.isEnumValue(args[0], TimeSignatures)) {
+      let parts = args[0].split("/");
+      this.beatCount = +parts[0];
+      this.beatSize = +parts[1];
+      if (guard_exports.isEnumValue(args[1], BeamGrouping)) {
+        beamGrouping = args[1];
+      }
+    } else if (guard_exports.isIntegerGte(args[0], 2) && guard_exports.isIntegerGte(args[1], 2)) {
+      this.beatCount = args[0];
+      this.beatSize = args[1];
+      if (guard_exports.isEnumValue(args[2], BeamGrouping)) {
+        beamGrouping = args[2];
+      }
+    } else {
+      throw new MusicError8(MusicErrorType8.Timesignature, `Invalid args: ${args}`);
+    }
+    if (!guard_exports.isIntegerGte(this.beatCount, 1)) {
+      throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beatCount: ${this.beatCount}`);
+    } else if (!guard_exports.isIntegerGte(this.beatSize, 1)) {
+      throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beatSize: ${this.beatSize}`);
+    }
+    let { noteLength, ticks } = NoteLengthProps.create(this.beatSize);
+    this.beatLength = noteLength;
+    this.measureTicks = this.beatCount * ticks;
+    if (this.is(2, 4)) {
+      this.beamGroupSizes = [[2], [2]];
+    } else if (this.is(3, 4)) {
+      this.beamGroupSizes = [[2], [2], [2]];
+    } else if (this.is(4, 4)) {
+      this.beamGroupSizes = [[2, 2], [2, 2]];
+    } else if (this.is(3, 8)) {
+      this.beamGroupSizes = [[3]];
+    } else if (this.is(5, 8)) {
+      if (!guard_exports.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
+        throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+      } else {
+        this.beamGroupSizes = beamGrouping === "3-2" /* _3_2 */ ? [[3], [2]] : [[2], [3]];
+        beamGrouping = void 0;
+      }
+    } else if (this.is(6, 8)) {
+      this.beamGroupSizes = [[3], [3]];
+    } else if (this.is(7, 8)) {
+      if (!guard_exports.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
+        throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+      } else {
+        this.beamGroupSizes = beamGrouping === "3-2-2" /* _3_2_2 */ ? [[3], [2], [2]] : [[2], [2], [3]];
+        beamGrouping = void 0;
+      }
+    } else if (this.is(9, 8)) {
+      this.beamGroupSizes = [[3], [3], [3]];
+    } else if (this.is(12, 8)) {
+      this.beamGroupSizes = [[3], [3], [3], [3]];
+    }
+    if (this.beamGroupSizes.length === 0) {
+      throw new MusicError8(MusicErrorType8.Timesignature, `Unimplemented time signature "${this.toString()}".`);
+    } else if (beamGrouping !== void 0) {
+      throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+    }
+  }
+  /**
+   * Test whether this time signature has given beat count and size.
+   * @param beatCount - Beat count.
+   * @param beatSize - Beat size.
+   * @returns - Boolean whether this time signature match given beat count and size.
+   */
+  is(beatCount, beatSize) {
+    return this.beatCount === beatCount && this.beatSize === beatSize;
+  }
+  /**
+   * Get string representation of this time signature (e.g. "3/4").
+   * @returns - String representation.
+   */
+  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: "4n" /* Quarter */, dotCount: 0 } };
+  }
+  return defaultTempo;
+}
+function getTempoString(tempo) {
+  return RhythmProps.get(tempo.options.beatLength, tempo.options.dotCount).toString() + "=" + tempo.beatsPerMinute;
+}
+function alterTempoSpeed(tempo, speed) {
+  return {
+    beatsPerMinute: tempo.beatsPerMinute * speed,
+    options: { beatLength: tempo.options.beatLength, dotCount: tempo.options.dotCount }
+  };
+}
+
+// src/theory/index.ts
+import { init as initCore } from "web-music-score/core";
+initCore();
+export {
+  AccidentalType,
+  BeamGrouping,
+  Chord,
+  DefaultGuitarNoteLabel,
+  DefaultPitchNotation,
+  DefaultTuningName,
+  GuitarNoteLabel,
+  GuitarNoteLabelList,
+  Interval,
+  KeySignature,
+  Mode,
+  Note,
+  NoteLength,
+  NoteLengthProps,
+  PitchNotation,
+  PitchNotationList,
+  RhythmProps,
+  Scale,
+  ScaleFactory,
+  ScaleType,
+  SymbolSet,
+  TimeSignature,
+  TimeSignatures,
+  TuningNameList,
+  Tuplet,
+  alterTempoSpeed,
+  getDefaultKeySignature,
+  getDefaultScale,
+  getDefaultTempo,
+  getDefaultTimeSignature,
+  getPitchNotationName,
+  getScale,
+  getScaleFactory,
+  getScaleFactoryList,
+  getTempoString,
+  getTuningStrings,
+  isNoteLength,
+  isTupletRatio,
+  validateGuitarNoteLabel,
+  validateIntervalQuality,
+  validateNoteLength,
+  validatePitchNotation,
+  validateScaleType,
+  validateTuningName,
+  validateTupletRatio
+};
+//# sourceMappingURL=index.mjs.map