@tspro/web-music-score 3.2.0 → 4.0.1

package/dist/theory/index.js

@@ -1,4 +1,4 @@
-/* WebMusicScore v3.2.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
+/* WebMusicScore v4.0.1 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -34,11 +34,10 @@ __export(theory_exports, {
   Handedness: () => Handedness,
   Interval: () => Interval,
   KeySignature: () => KeySignature,
-  MaxNoteLength: () => MaxNoteLength,
-  MinNoteLength: () => MinNoteLength,
   Mode: () => Mode,
   Note: () => Note,
   NoteLength: () => NoteLength,
+  NoteLengthProps: () => NoteLengthProps,
   PitchNotation: () => PitchNotation,
   PitchNotationList: () => PitchNotationList,
   RhythmProps: () => RhythmProps,
@@ -48,6 +47,7 @@ __export(theory_exports, {
   SymbolSet: () => SymbolSet,
   TimeSignature: () => TimeSignature,
   TuningNameList: () => TuningNameList,
+  Tuplet: () => Tuplet,
   alterTempoSpeed: () => alterTempoSpeed,
   getDefaultKeySignature: () => getDefaultKeySignature,
   getDefaultScale: () => getDefaultScale,
@@ -65,7 +65,8 @@ __export(theory_exports, {
   validateNoteLength: () => validateNoteLength,
   validatePitchNotation: () => validatePitchNotation,
   validateScaleType: () => validateScaleType,
-  validateTuningName: () => validateTuningName
+  validateTuningName: () => validateTuningName,
+  validateTupletRatio: () => validateTupletRatio
 });
 module.exports = __toCommonJS(theory_exports);
 
@@ -91,10 +92,10 @@ var PitchNotation = /* @__PURE__ */ ((PitchNotation2) => {
 var PitchNotationList = import_ts_utils_lib.Utils.Enum.getEnumValues(PitchNotation);
 var DefaultPitchNotation = 0 /* Scientific */;
 function validatePitchNotation(pn) {
-  if (!import_ts_utils_lib.Utils.Is.isEnumValue(pn, PitchNotation)) {
-    throw new import_core.MusicError(import_core.MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
-  } else {
+  if (import_ts_utils_lib.Utils.Is.isEnumValue(pn, PitchNotation)) {
     return pn;
+  } else {
+    throw new import_core.MusicError(import_core.MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
   }
 }
 function getPitchNotationName(pn) {
@@ -109,10 +110,10 @@ var GuitarNoteLabel = /* @__PURE__ */ ((GuitarNoteLabel2) => {
 var DefaultGuitarNoteLabel = "Default" /* Default */;
 var GuitarNoteLabelList = import_ts_utils_lib.Utils.Enum.getEnumValues(GuitarNoteLabel);
 function validateGuitarNoteLabel(label) {
-  if (!import_ts_utils_lib.Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
-    throw new import_core.MusicError(import_core.MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
-  } else {
+  if (import_ts_utils_lib.Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
     return label;
+  } else {
+    throw new import_core.MusicError(import_core.MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
   }
 }
 
@@ -131,8 +132,11 @@ 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);
@@ -151,21 +155,32 @@ var _Note = class _Note {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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);
@@ -179,11 +194,21 @@ var _Note = class _Note {
       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) {
     let note = this.noteByNameCache.get(noteName);
     if (note === void 0) {
@@ -199,6 +224,11 @@ var _Note = class _Note {
     }
     return note;
   }
+  /**
+   * 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) {
     let note = this.chromaticNoteCache.get(chromaticId);
     if (note === void 0) {
@@ -225,21 +255,54 @@ var _Note = class _Note {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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;
@@ -249,6 +312,12 @@ var _Note = class _Note {
       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}");
@@ -256,9 +325,19 @@ var _Note = class _Note {
       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);
@@ -272,6 +351,12 @@ var _Note = class _Note {
     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) {
@@ -280,9 +365,20 @@ var _Note = class _Note {
     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) {
@@ -290,15 +386,32 @@ var _Note = class _Note {
     }
     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 (import_ts_utils_lib2.Utils.Is.isInteger(diatonicId)) {
       return diatonicId;
@@ -306,13 +419,23 @@ var _Note = class _Note {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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 (import_ts_utils_lib2.Utils.Is.isInteger(diatonicClass) && diatonicClass >= 0 && diatonicClass < 7) {
+    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(diatonicClass, 0, 6)) {
       return diatonicClass;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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 (import_ts_utils_lib2.Utils.Is.isInteger(chromaticId)) {
       return chromaticId;
@@ -320,20 +443,35 @@ var _Note = class _Note {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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 (import_ts_utils_lib2.Utils.Is.isInteger(chromaticClass) && chromaticClass >= 0 && chromaticClass < 12) {
+    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(chromaticClass, 0, 11)) {
       return chromaticClass;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid chromaticClass: ${chromaticClass}`);
     }
   }
-  static validateNoteLetter(note) {
-    if (NoteLetters.some((n) => n === note)) {
-      return note;
+  /**
+   * 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 import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note: ${note}`);
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note: ${noteLetter}`);
     }
   }
+  /**
+   * Validate if given argument is octave.
+   * @param octave - Octave to validate.
+   * @returns - Valid octave or throws.
+   */
   static validateOctave(octave) {
     if (import_ts_utils_lib2.Utils.Is.isInteger(octave)) {
       return octave;
@@ -341,8 +479,13 @@ var _Note = class _Note {
       throw new import_core2.MusicError(import_core2.MusicErrorType.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 (import_ts_utils_lib2.Utils.Is.isInteger(acc) && acc >= -2 && acc <= 2) {
+    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(acc, -2, 2)) {
       return acc;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid accidental: ${acc}`);
@@ -370,6 +513,12 @@ var _Note = class _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;
@@ -491,6 +640,10 @@ var _KeySignature = class _KeySignature {
     }
     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 */;
@@ -500,23 +653,40 @@ var _KeySignature = class _KeySignature {
       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;
   }
   /**
-   * 
-   * @param degree - number 1..7 or string e.g "b5" or "#4"
-   * @returns 
+   * 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);
@@ -527,6 +697,12 @@ var _KeySignature = class _KeySignature {
       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;
@@ -664,9 +840,13 @@ 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";
@@ -684,6 +864,12 @@ var Interval = class _Interval {
       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);
@@ -695,12 +881,20 @@ var Interval = class _Interval {
       }
     }
   }
+  /**
+   * 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() {
     var _a;
     let direction = this.direction === "Descending" ? "\u2193" : "";
@@ -795,12 +989,20 @@ function getMode(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, "preferredChromaticNoteCache", /* @__PURE__ */ new Map());
     switch (scaleType) {
@@ -832,6 +1034,12 @@ var Scale = class extends KeySignature {
       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;
@@ -841,6 +1049,11 @@ var Scale = class extends KeySignature {
       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 */:
@@ -849,6 +1062,12 @@ var Scale = class extends KeySignature {
         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 (!import_ts_utils_lib5.Utils.Is.isIntegerGte(numOctaves, 1)) {
       throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid numOctaves: ${numOctaves}`);
@@ -864,9 +1083,17 @@ var Scale = class extends KeySignature {
       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 = [];
@@ -875,15 +1102,34 @@ var Scale = class extends KeySignature {
     }
     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) {
@@ -899,6 +1145,11 @@ var Scale = class extends KeySignature {
       return interval;
     }
   }
+  /**
+   * Get preferred chromatic note from given chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Note.
+   */
   getPreferredChromaticNote(chromaticId) {
     Note.validateChromaticId(chromaticId);
     let note = this.preferredChromaticNoteCache.get(chromaticId);
@@ -941,6 +1192,10 @@ var Scale = class extends KeySignature {
   }
 };
 var ScaleFactory = class {
+  /**
+   * Create new scale factory object instance.
+   * @param type - Scale type.
+   */
   constructor(type) {
     this.type = type;
     __publicField(this, "tonicList", []);
@@ -986,15 +1241,32 @@ var ScaleFactory = class {
       ...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) {
@@ -1003,6 +1275,11 @@ var ScaleFactory = class {
       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;
   }
@@ -1048,10 +1325,19 @@ function validateScaleType(scaleType) {
   if (import_ts_utils_lib5.Utils.Is.isEnumValue(scaleType, ScaleType)) {
     return scaleType;
   } else {
-    throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: ${scaleType}`);
+    throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: "${scaleType}"`);
   }
 }
-function getScale(tonic, 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 */);
@@ -1158,9 +1444,13 @@ 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();
@@ -1199,6 +1489,11 @@ var Chord = class _Chord {
       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);
@@ -1238,7 +1533,8 @@ var Chord = class _Chord {
     return true;
   }
   /**
-   * @returns Chord name e.g. "C/B"
+   * Get chord string presentation.
+   * @returns Chord string presentation (e.g. "C/B").
    */
   toString() {
     let symbolSet = 1 /* Unicode */;
@@ -1247,7 +1543,8 @@ var Chord = class _Chord {
     return rootNoteStr + this.name + slashBassStr;
   }
   /**
-   * @returns Degree notation string, e.g. "E - 1(C) - 3(E) - 5(G)"
+   * Get degree notation string (e.g. "E - 1(C) - 3(E) - 5(G)").
+   * @returns Degree notation string.
    */
   getDegreeNotationString() {
     let symbolSet = 1 /* Unicode */;
@@ -1258,7 +1555,8 @@ var Chord = class _Chord {
     return bassNoteStr + degreeNoteStr;
   }
   /**
-   * @returns Omitted degrees string e.g. "Omits 5(G), 9(D)"
+   * 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) => {
@@ -1267,15 +1565,17 @@ var Chord = class _Chord {
     return omittedStrList.length > 0 ? "Omits " + omittedStrList.join(", ") : "";
   }
   /**
-   * @param i - Degree index
-   * @returns Degree string for given degree index, e.g. "3"
+   * 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 */);
   }
   /**
-   * @param i - Degree index
-   * @returns Note string for given degree index, e.g. "E"
+   * 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 */);
@@ -1542,10 +1842,10 @@ var Handedness = /* @__PURE__ */ ((Handedness2) => {
 })(Handedness || {});
 var DefaultHandedness = 0 /* RightHanded */;
 function validateHandedness(h) {
-  if (!import_ts_utils_lib7.Utils.Is.isEnumValue(h, Handedness)) {
-    throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid handedness: ${h}`);
-  } else {
+  if (import_ts_utils_lib7.Utils.Is.isEnumValue(h, Handedness)) {
     return h;
+  } else {
+    throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid handedness: ${h}`);
   }
 }
 var TuningNameList = tunings_default.list.map((data) => data.name);
@@ -1580,92 +1880,268 @@ var import_ts_utils_lib9 = require("@tspro/ts-utils-lib");
 // src/theory/rhythm.ts
 var import_ts_utils_lib8 = require("@tspro/ts-utils-lib");
 var import_core8 = require("@tspro/web-music-score/core");
+var cmp = (a, b) => a === b ? 0 : a < b ? -1 : 1;
+var MaxTupletRatioValue = 12;
+var TicksMultiplier = 12 * 11 * 9 * 7 * 5;
 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";
+  NoteLength3["Whole"] = "1n";
+  NoteLength3["WholeTriplet"] = "1t";
+  NoteLength3["WholeDot"] = "1.";
+  NoteLength3["Whole2Dots"] = "1..";
+  NoteLength3["Whole12Dots"] = "1..";
+  NoteLength3["Whole3Dots"] = "1...";
+  NoteLength3["Whole4Dots"] = "1....";
+  NoteLength3["Whole5Dots"] = "1.....";
+  NoteLength3["Whole6Dots"] = "1......";
+  NoteLength3["Half"] = "2n";
+  NoteLength3["HalfTriplet"] = "2t";
+  NoteLength3["HalfDot"] = "2.";
+  NoteLength3["Half2Dots"] = "2..";
+  NoteLength3["Half3Dots"] = "2...";
+  NoteLength3["Half4Dots"] = "2....";
+  NoteLength3["Half5Dots"] = "2.....";
+  NoteLength3["Quarter"] = "4n";
+  NoteLength3["QuarterTriplet"] = "4t";
+  NoteLength3["QuarterDot"] = "4.";
+  NoteLength3["Quarter2Dots"] = "4..";
+  NoteLength3["Quarter3Dots"] = "4...";
+  NoteLength3["Quarter4Dots"] = "4....";
+  NoteLength3["Eighth"] = "8n";
+  NoteLength3["EighthTriplet"] = "8t";
+  NoteLength3["EighthDot"] = "8.";
+  NoteLength3["Eighth2Dots"] = "8..";
+  NoteLength3["Eighth3Dots"] = "8...";
+  NoteLength3["Sixteenth"] = "16n";
+  NoteLength3["SixteenthTriplet"] = "16t";
+  NoteLength3["SixteenthDot"] = "16.";
+  NoteLength3["Sixteenth2Dots"] = "16..";
+  NoteLength3["ThirtySecond"] = "32n";
+  NoteLength3["ThirtySecondTriplet"] = "32t";
+  NoteLength3["ThirtySecondDot"] = "32.";
+  NoteLength3["SixtyFourth"] = "64n";
+  NoteLength3["SixtyFourthTriplet"] = "64t";
   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 (!import_ts_utils_lib8.Utils.Is.isEnumValue(noteLength, NoteLength)) {
+  if (import_ts_utils_lib8.Utils.Is.isEnumValue(noteLength, NoteLength)) {
+    return noteLength;
+  } else {
     throw new import_core8.MusicError(import_core8.MusicErrorType.InvalidArg, `Invalid noteLength: ${noteLength}`);
+  }
+}
+var _NoteLengthProps = class _NoteLengthProps {
+  constructor(noteLength) {
+    /** Note length. */
+    __publicField(this, "noteLength");
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    __publicField(this, "noteSize");
+    /** Number of ticks (not altered by isTriplet). */
+    __publicField(this, "ticks");
+    /** Flag count. */
+    __publicField(this, "flagCount");
+    /** Dot count. */
+    __publicField(this, "dotCount");
+    /** Max dot count. */
+    __publicField(this, "maxDotCount");
+    /** Is triplet? */
+    __publicField(this, "isTriplet");
+    /** Has note stem. */
+    __publicField(this, "hasStem");
+    /** Is note head solid (black)? */
+    __publicField(this, "isSolid");
+    this.noteLength = validateNoteLength(noteLength);
+    this.noteSize = parseInt(noteLength);
+    this.isTriplet = noteLength.endsWith("t");
+    this.maxDotCount = this.isTriplet ? 0 : Math.floor(Math.log2(_NoteLengthProps.ShortestNoteSize / this.noteSize));
+    this.dotCount = import_ts_utils_lib8.Utils.Str.charCount(noteLength, ".");
+    this.flagCount = this.noteSize > 4 ? Math.floor(Math.log2(this.noteSize / 4)) : 0;
+    this.ticks = TicksMultiplier * _NoteLengthProps.ShortestNoteSize / this.noteSize;
+    this.hasStem = this.noteSize > 1;
+    this.isSolid = this.noteSize > 2;
+    if (this.dotCount > this.maxDotCount) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `dotCount ${this.dotCount} > maxDotCount ${this.maxDotCount}, for noteLength "${this.noteLength}".`);
+    } else if (this.isTriplet && this.dotCount > 0) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `noteLength "${this.noteLength}" is both triplet and dotted!`);
+    }
+  }
+  /**
+   * Get note length props.
+   * @param noteLength - Note length.
+   * @returns - Note length props.
+   */
+  static get(noteLength) {
+    let p = this.cache.get(noteLength);
+    if (!p) {
+      this.cache.set(noteLength, p = new _NoteLengthProps(noteLength));
+    }
+    return p;
+  }
+  /**
+   * Create note length props.
+   * @param noteLength - Note length or note size.
+   * @param dotCount - Dot count.
+   * @returns - Note length props.
+   */
+  static create(noteLength, dotCount = 0) {
+    let noteSize = typeof noteLength === "number" ? noteLength : this.get(noteLength).noteSize;
+    return this.get(noteSize + (import_ts_utils_lib8.Utils.Is.isIntegerGte(dotCount, 1) ? ".".repeat(dotCount) : "n"));
+  }
+  /**
+   * Compare note lengths/sizes. Whole (1) > half (2) > quarter (4), etc.
+   * Ignores possible triplet property of note length.
+   * @param a - NoteLengthProps, NoteLength/Str or noteSize
+   * @param b - NoteLengthProps, NoteLength/Str or noteSize
+   * @returns - -1: a < b, 0: a === b, +1: a > b (note length/size comparisons)
+   */
+  static cmp(a, b) {
+    let aNoteSize = a instanceof _NoteLengthProps ? a.noteSize : typeof a === "number" ? a : _NoteLengthProps.get(a).noteSize;
+    let bNoteSize = b instanceof _NoteLengthProps ? b.noteSize : typeof b === "number" ? b : _NoteLengthProps.get(b).noteSize;
+    return cmp(bNoteSize, aNoteSize);
+  }
+  /**
+   * Compare note lengths/sizes for equality.
+   * Ignores possible triplet property of note length.
+   * @param a - NoteLengthProps, NoteLength/Str or noteSize
+   * @param b - NoteLengthProps, NoteLength/Str or noteSize
+   * @returns - true: a === b, false: a !== b (note length/size comparisons)
+   */
+  static equals(a, b) {
+    let aNoteSize = a instanceof _NoteLengthProps ? a.noteSize : typeof a === "number" ? a : _NoteLengthProps.get(a).noteSize;
+    let bNoteSize = b instanceof _NoteLengthProps ? b.noteSize : typeof b === "number" ? b : _NoteLengthProps.get(b).noteSize;
+    return aNoteSize === bNoteSize;
+  }
+};
+/** Longest note size (e.g. 1 = whole note). */
+__publicField(_NoteLengthProps, "LongestNoteSize", Math.min(...import_ts_utils_lib8.Utils.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+/** Shortest note size (e.g. 64 = sixtyfourth note). */
+__publicField(_NoteLengthProps, "ShortestNoteSize", Math.max(...import_ts_utils_lib8.Utils.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+__publicField(_NoteLengthProps, "cache", /* @__PURE__ */ new Map());
+var NoteLengthProps = _NoteLengthProps;
+function validateTupletRatio(tupletRatio) {
+  if (import_ts_utils_lib8.Utils.Is.isObject(tupletRatio) && import_ts_utils_lib8.Utils.Is.isIntegerBetween(tupletRatio.parts, 2, MaxTupletRatioValue) && import_ts_utils_lib8.Utils.Is.isIntegerBetween(tupletRatio.inTimeOf, 2, MaxTupletRatioValue)) {
+    return tupletRatio;
   } else {
-    return noteLength;
+    throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Invalid tupletRatio ${JSON.stringify(tupletRatio)}`);
   }
 }
-var RhythmProps = class _RhythmProps {
-  constructor(noteLength, dotted, triplet) {
+var Tuplet = {
+  /** Duplet: 2 in the time of 3 */
+  Duplet: { parts: 2, inTimeOf: 3 },
+  /** Triplet: 3 in the time of 2 */
+  Triplet: { parts: 3, inTimeOf: 2 },
+  /** Quadruplet: 4 in the time of 3 */
+  Quadruplet: { parts: 4, inTimeOf: 3 }
+};
+var _RhythmProps = class _RhythmProps {
+  constructor(noteLength, dotCount, tupletRatio) {
+    /** Note length. */
     __publicField(this, "noteLength");
-    __publicField(this, "dotted");
-    __publicField(this, "triplet");
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    __publicField(this, "noteSize");
+    /** Dot count. */
+    __publicField(this, "dotCount");
+    /** Tuplet ratio. */
+    __publicField(this, "tupletRatio");
+    /** Number of ticks. */
     __publicField(this, "ticks");
+    /** Flag count. */
     __publicField(this, "flagCount");
-    var _a;
+    /** Has note stem. */
+    __publicField(this, "hasStem");
+    /** Is note head solid (black)? */
+    __publicField(this, "isSolidNoteHead");
     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 import_core8.MusicError(import_core8.MusicErrorType.Note, "Note cannot be both dotted and triplet!");
-    } else if (this.dotted && this.noteLength === MinNoteLength) {
-      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, "Shortest note cannot be dotted!");
+    let p = NoteLengthProps.get(noteLength);
+    this.noteSize = p.noteSize;
+    this.ticks = p.ticks;
+    this.flagCount = p.flagCount;
+    this.dotCount = dotCount != null ? dotCount : p.dotCount;
+    this.hasStem = p.hasStem;
+    this.isSolidNoteHead = p.isSolid;
+    if (import_ts_utils_lib8.Utils.Is.isObject(tupletRatio)) {
+      this.tupletRatio = validateTupletRatio(tupletRatio);
+    } else if (p.isTriplet) {
+      this.tupletRatio = Tuplet.Triplet;
+    } else {
+      this.tupletRatio = void 0;
+    }
+    if (this.dotCount > 0 && this.tupletRatio !== void 0) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Note cannot be both dotted and tuplet!`);
+    } else if (this.dotCount > p.maxDotCount) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Too big dot count ${this.dotCount} for note length ${this.noteLength}.`);
     }
-    if (this.dotted) {
-      this.ticks += this.noteLength / 2;
+    for (let add = this.ticks / 2, i = 1; i <= this.dotCount; i++, add /= 2) {
+      this.ticks += add;
     }
-    if (this.triplet) {
-      this.ticks = this.ticks * 2 / 3;
+    if (this.tupletRatio) {
+      this.ticks *= this.tupletRatio.inTimeOf / this.tupletRatio.parts;
     }
   }
-  static createFromNoteSize(noteSize) {
-    return new _RhythmProps(MaxNoteLength / noteSize);
+  /**
+   * Get string presentation of rhythm props.
+   * @returns - String presentation.
+   */
+  toString() {
+    let sym = _RhythmProps.NoteSymbolMap.get(this.noteSize);
+    let dots = ".".repeat(this.dotCount);
+    return sym ? sym + dots : "" + this.noteSize + (dots.length > 0 ? dots : "n");
   }
-  canDot() {
-    return !this.dotted && this.noteLength !== MinNoteLength;
+  /**
+   * Get rhythm props with given arguments.
+   * @param noteLength - Note length.
+   * @param dotCount - Dot count.
+   * @param tupletRatio - Tuplet ratio.
+   * @returns - Rhythm props.
+   */
+  static get(noteLength, dotCount, tupletRatio) {
+    if (dotCount !== void 0 || tupletRatio !== void 0) {
+      return new _RhythmProps(noteLength, dotCount, tupletRatio);
+    } else {
+      let rhythmProps = this.cache.get(noteLength);
+      if (!rhythmProps) {
+        this.cache.set(noteLength, rhythmProps = new _RhythmProps(noteLength));
+      }
+      return rhythmProps;
+    }
   }
-  hasStem() {
-    return this.noteLength < 192 /* Whole */;
+  /**
+   * Compare duration of rhythm props.
+   * @param a - RhythmProps
+   * @param b - RhythmProps
+   * @returns - -1: a < b, 0: a === b, +1: a > b (duration comparisons)
+   */
+  static cmp(a, b) {
+    return cmp(a.ticks, b.ticks);
   }
-  toString() {
-    return NoteSymbolMap.get(this.noteLength) + (this.dotted ? "." : "");
+  /**
+   * Compare duration equality of rhythm props.
+   * @param a - RhythmProps
+   * @param b - RhythmProps
+   * @returns - true: a === b, false: a !== b (duration comparisons)
+   */
+  static equals(a, b) {
+    return a.ticks === b.ticks;
   }
 };
+__publicField(_RhythmProps, "NoteSymbolMap", /* @__PURE__ */ new Map([[1, "\u{1D15D}"], [2, "\u{1D15E}"], [4, "\u{1D15F}"], [8, "\u{1D160}"], [16, "\u{1D161}"], [32, "\u{1D162}"], [64, "\u{1D163}"], [128, "\u{1D164}"]]));
+__publicField(_RhythmProps, "cache", /* @__PURE__ */ new Map());
+var RhythmProps = _RhythmProps;
 
 // src/theory/time-signature.ts
 var import_core9 = require("@tspro/web-music-score/core");
 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");
-    /** Lengths in ticks */
+    /** Beat length. */
     __publicField(this, "beatLength");
+    /** Number of ticks in measure. */
     __publicField(this, "measureTicks");
+    /** Number of beam groups in measure. */
     __publicField(this, "beamGroupCount");
+    /** Length of one beam group. */
     __publicField(this, "beamGroupLength");
     if (args.length === 1 && typeof args[0] === "string") {
       let parts = args[0].split("/");
@@ -1682,9 +2158,9 @@ var TimeSignature = class {
     } else if (!import_ts_utils_lib9.Utils.Is.isIntegerGte(this.beatSize, 1)) {
       throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beatSize: ${this.beatSize}`);
     }
-    let beatLengthValue = RhythmProps.createFromNoteSize(this.beatSize);
-    this.beatLength = beatLengthValue.noteLength;
-    this.measureTicks = this.beatCount * beatLengthValue.ticks;
+    let props = NoteLengthProps.create(this.beatSize);
+    this.beatLength = props.noteLength;
+    this.measureTicks = this.beatCount * props.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)) {
@@ -1698,9 +2174,19 @@ var TimeSignature = class {
       throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beamGroupLength: ${this.beamGroupLength}`);
     }
   }
+  /**
+   * 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;
   }
@@ -1717,17 +2203,17 @@ function getDefaultTimeSignature() {
 var defaultTempo;
 function getDefaultTempo() {
   if (!defaultTempo) {
-    defaultTempo = { beatsPerMinute: 120, options: { beatLength: 48 /* Quarter */, dotted: false } };
+    defaultTempo = { beatsPerMinute: 120, options: { beatLength: "4n" /* Quarter */, dotCount: 0 } };
   }
   return defaultTempo;
 }
 function getTempoString(tempo) {
-  return new RhythmProps(tempo.options.beatLength, tempo.options.dotted).toString() + "=" + tempo.beatsPerMinute;
+  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, dotted: tempo.options.dotted }
+    options: { beatLength: tempo.options.beatLength, dotCount: tempo.options.dotCount }
   };
 }
 
@@ -1747,11 +2233,10 @@ var import_core10 = require("@tspro/web-music-score/core");
   Handedness,
   Interval,
   KeySignature,
-  MaxNoteLength,
-  MinNoteLength,
   Mode,
   Note,
   NoteLength,
+  NoteLengthProps,
   PitchNotation,
   PitchNotationList,
   RhythmProps,
@@ -1761,6 +2246,7 @@ var import_core10 = require("@tspro/web-music-score/core");
   SymbolSet,
   TimeSignature,
   TuningNameList,
+  Tuplet,
   alterTempoSpeed,
   getDefaultKeySignature,
   getDefaultScale,
@@ -1778,6 +2264,7 @@ var import_core10 = require("@tspro/web-music-score/core");
   validateNoteLength,
   validatePitchNotation,
   validateScaleType,
-  validateTuningName
+  validateTuningName,
+  validateTupletRatio
 });
 //# sourceMappingURL=index.js.map