@tspro/web-music-score 5.2.0 → 5.4.0

package/dist/{tempo-dkctPkCS.d.mts → tempo-BlCGZuYg.d.mts}

@@ -1,4 +1,4 @@
-import { N as Note, A as Accidental } from './note-eA2xPPiG.mjs';
+import { N as Note, A as Accidental } from './note-RVXvpfyV.mjs';
 
 /** Mode enum. */
 declare enum Mode {
@@ -162,6 +162,12 @@ declare enum NoteLength {
 }
 /** String values type of note length enum. */
 type NoteLengthStr = `${NoteLength}`;
+/**
+ * Test if given argument is note length.
+ * @param noteLength - Note length to validate.
+ * @returns - True/false.
+ */
+declare function isNoteLength(noteLength: unknown): noteLength is NoteLength;
 /**
  * Validate if given argument is note length.
  * @param noteLength - Note length to validate.
@@ -231,6 +237,12 @@ interface TupletRatio {
     /** Played int time of (notes). */
     inTimeOf: number;
 }
+/**
+ * Test if given argument is tuplet ratio.
+ * @param tupletRatio - Tuplet ratio to validate.
+ * @returns - True/false.
+ */
+declare function isTupletRatio(tupletRatio: unknown): tupletRatio is TupletRatio;
 /**
  * Validate if given argument is tuplet ratio.
  * @param tupletRatio - Tuplet ratio to validate.
@@ -398,4 +410,4 @@ declare function getTempoString(tempo: Tempo): string;
  */
 declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
 
-export { AccidentalType as A, BeamGrouping as B, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, TimeSignatures as T, type TimeSignatureString as a, TimeSignature as b, getDefaultTimeSignature as c, type Tempo as d, getDefaultTempo as e, getTempoString as f, getDefaultKeySignature as g, alterTempoSpeed as h, type NoteLengthStr as i, NoteLengthProps as j, type TupletRatio as k, validateTupletRatio as l, Tuplet as m, validateNoteLength as v };
+export { AccidentalType as A, BeamGrouping as B, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, TimeSignatures as T, type TimeSignatureString as a, TimeSignature as b, getDefaultTimeSignature as c, type Tempo as d, getDefaultTempo as e, getTempoString as f, getDefaultKeySignature as g, alterTempoSpeed as h, type NoteLengthStr as i, isNoteLength as j, NoteLengthProps as k, type TupletRatio as l, isTupletRatio as m, validateTupletRatio as n, Tuplet as o, validateNoteLength as v };

package/dist/{tempo-DMt3iwz9.d.ts → tempo-BnUjm25M.d.ts}

@@ -1,4 +1,4 @@
-import { N as Note, A as Accidental } from './note-CgCIBwvR.js';
+import { N as Note, A as Accidental } from './note-CJuq5aBy.js';
 
 /** Mode enum. */
 declare enum Mode {
@@ -162,6 +162,12 @@ declare enum NoteLength {
 }
 /** String values type of note length enum. */
 type NoteLengthStr = `${NoteLength}`;
+/**
+ * Test if given argument is note length.
+ * @param noteLength - Note length to validate.
+ * @returns - True/false.
+ */
+declare function isNoteLength(noteLength: unknown): noteLength is NoteLength;
 /**
  * Validate if given argument is note length.
  * @param noteLength - Note length to validate.
@@ -231,6 +237,12 @@ interface TupletRatio {
     /** Played int time of (notes). */
     inTimeOf: number;
 }
+/**
+ * Test if given argument is tuplet ratio.
+ * @param tupletRatio - Tuplet ratio to validate.
+ * @returns - True/false.
+ */
+declare function isTupletRatio(tupletRatio: unknown): tupletRatio is TupletRatio;
 /**
  * Validate if given argument is tuplet ratio.
  * @param tupletRatio - Tuplet ratio to validate.
@@ -398,4 +410,4 @@ declare function getTempoString(tempo: Tempo): string;
  */
 declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
 
-export { AccidentalType as A, BeamGrouping as B, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, TimeSignatures as T, type TimeSignatureString as a, TimeSignature as b, getDefaultTimeSignature as c, type Tempo as d, getDefaultTempo as e, getTempoString as f, getDefaultKeySignature as g, alterTempoSpeed as h, type NoteLengthStr as i, NoteLengthProps as j, type TupletRatio as k, validateTupletRatio as l, Tuplet as m, validateNoteLength as v };
+export { AccidentalType as A, BeamGrouping as B, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, TimeSignatures as T, type TimeSignatureString as a, TimeSignature as b, getDefaultTimeSignature as c, type Tempo as d, getDefaultTempo as e, getTempoString as f, getDefaultKeySignature as g, alterTempoSpeed as h, type NoteLengthStr as i, isNoteLength as j, NoteLengthProps as k, type TupletRatio as l, isTupletRatio as m, validateTupletRatio as n, Tuplet as o, validateNoteLength as v };

package/dist/theory/index.d.mts

@@ -1,9 +1,9 @@
-import { N as Note } from '../note-eA2xPPiG.mjs';
-export { A as Accidental, d as DefaultGuitarNoteLabel, D as DefaultPitchNotation, G as GuitarNoteLabel, e as GuitarNoteLabelList, a as NoteLetter, P as ParsedNote, b as PitchNotation, c as PitchNotationList, S as SymbolSet, g as getPitchNotationName, f as validateGuitarNoteLabel, v as validatePitchNotation } from '../note-eA2xPPiG.mjs';
-import { D as Degree } from '../scale-DQP3b9Zx.mjs';
-export { b as Interval, I as IntervalDirection, a as IntervalQuality, c as Scale, d as ScaleFactory, S as ScaleType, i as getDefaultScale, h as getScale, e as getScaleFactory, g as getScaleFactoryList, v as validateIntervalQuality, f as validateScaleType } from '../scale-DQP3b9Zx.mjs';
-export { D as DefaultHandedness, a as DefaultTuningName, H as Handedness, T as TuningNameList, g as getTuningStrings, v as validateHandedness, b as validateTuningName } from '../guitar-DdexKdN6.mjs';
-export { A as AccidentalType, B as BeamGrouping, K as KeySignature, M as Mode, N as NoteLength, j as NoteLengthProps, i as NoteLengthStr, R as RhythmProps, d as Tempo, b as TimeSignature, a as TimeSignatureString, T as TimeSignatures, m as Tuplet, k as TupletRatio, h as alterTempoSpeed, g as getDefaultKeySignature, e as getDefaultTempo, c as getDefaultTimeSignature, f as getTempoString, v as validateNoteLength, l as validateTupletRatio } from '../tempo-dkctPkCS.mjs';
+import { N as Note } from '../note-RVXvpfyV.mjs';
+export { A as Accidental, d as DefaultGuitarNoteLabel, D as DefaultPitchNotation, G as GuitarNoteLabel, e as GuitarNoteLabelList, a as NoteLetter, P as ParsedNote, b as PitchNotation, c as PitchNotationList, S as SymbolSet, g as getPitchNotationName, f as validateGuitarNoteLabel, v as validatePitchNotation } from '../note-RVXvpfyV.mjs';
+import { D as Degree } from '../scale-C8gHC448.mjs';
+export { b as Interval, I as IntervalDirection, a as IntervalQuality, c as Scale, d as ScaleFactory, S as ScaleType, i as getDefaultScale, h as getScale, e as getScaleFactory, g as getScaleFactoryList, v as validateIntervalQuality, f as validateScaleType } from '../scale-C8gHC448.mjs';
+export { D as DefaultHandedness, a as DefaultTuningName, H as Handedness, T as TuningNameList, g as getTuningStrings, v as validateHandedness, b as validateTuningName } from '../guitar-DXlB-9vK.mjs';
+export { A as AccidentalType, B as BeamGrouping, K as KeySignature, M as Mode, N as NoteLength, k as NoteLengthProps, i as NoteLengthStr, R as RhythmProps, d as Tempo, b as TimeSignature, a as TimeSignatureString, T as TimeSignatures, o as Tuplet, l as TupletRatio, h as alterTempoSpeed, g as getDefaultKeySignature, e as getDefaultTempo, c as getDefaultTimeSignature, f as getTempoString, j as isNoteLength, m as isTupletRatio, v as validateNoteLength, n as validateTupletRatio } from '../tempo-BlCGZuYg.mjs';
 
 /** Chord info type. */
 type ChordInfo = {

package/dist/theory/index.d.ts

@@ -1,9 +1,9 @@
-import { N as Note } from '../note-CgCIBwvR.js';
-export { A as Accidental, d as DefaultGuitarNoteLabel, D as DefaultPitchNotation, G as GuitarNoteLabel, e as GuitarNoteLabelList, a as NoteLetter, P as ParsedNote, b as PitchNotation, c as PitchNotationList, S as SymbolSet, g as getPitchNotationName, f as validateGuitarNoteLabel, v as validatePitchNotation } from '../note-CgCIBwvR.js';
-import { D as Degree } from '../scale-CBW4eTz7.js';
-export { b as Interval, I as IntervalDirection, a as IntervalQuality, c as Scale, d as ScaleFactory, S as ScaleType, i as getDefaultScale, h as getScale, e as getScaleFactory, g as getScaleFactoryList, v as validateIntervalQuality, f as validateScaleType } from '../scale-CBW4eTz7.js';
-export { D as DefaultHandedness, a as DefaultTuningName, H as Handedness, T as TuningNameList, g as getTuningStrings, v as validateHandedness, b as validateTuningName } from '../guitar-BsSayRsH.js';
-export { A as AccidentalType, B as BeamGrouping, K as KeySignature, M as Mode, N as NoteLength, j as NoteLengthProps, i as NoteLengthStr, R as RhythmProps, d as Tempo, b as TimeSignature, a as TimeSignatureString, T as TimeSignatures, m as Tuplet, k as TupletRatio, h as alterTempoSpeed, g as getDefaultKeySignature, e as getDefaultTempo, c as getDefaultTimeSignature, f as getTempoString, v as validateNoteLength, l as validateTupletRatio } from '../tempo-DMt3iwz9.js';
+import { N as Note } from '../note-CJuq5aBy.js';
+export { A as Accidental, d as DefaultGuitarNoteLabel, D as DefaultPitchNotation, G as GuitarNoteLabel, e as GuitarNoteLabelList, a as NoteLetter, P as ParsedNote, b as PitchNotation, c as PitchNotationList, S as SymbolSet, g as getPitchNotationName, f as validateGuitarNoteLabel, v as validatePitchNotation } from '../note-CJuq5aBy.js';
+import { D as Degree } from '../scale-DulPFco_.js';
+export { b as Interval, I as IntervalDirection, a as IntervalQuality, c as Scale, d as ScaleFactory, S as ScaleType, i as getDefaultScale, h as getScale, e as getScaleFactory, g as getScaleFactoryList, v as validateIntervalQuality, f as validateScaleType } from '../scale-DulPFco_.js';
+export { D as DefaultHandedness, a as DefaultTuningName, H as Handedness, T as TuningNameList, g as getTuningStrings, v as validateHandedness, b as validateTuningName } from '../guitar-CarHGDAt.js';
+export { A as AccidentalType, B as BeamGrouping, K as KeySignature, M as Mode, N as NoteLength, k as NoteLengthProps, i as NoteLengthStr, R as RhythmProps, d as Tempo, b as TimeSignature, a as TimeSignatureString, T as TimeSignatures, o as Tuplet, l as TupletRatio, h as alterTempoSpeed, g as getDefaultKeySignature, e as getDefaultTempo, c as getDefaultTimeSignature, f as getTempoString, j as isNoteLength, m as isTupletRatio, v as validateNoteLength, n as validateTupletRatio } from '../tempo-BnUjm25M.js';
 
 /** Chord info type. */
 type ChordInfo = {

package/dist/theory/index.js

@@ -1,4 +1,4 @@
-/* WebMusicScore v5.2.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
+/* WebMusicScore v5.4.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -61,6 +61,8 @@ __export(theory_exports, {
   getScaleFactoryList: () => getScaleFactoryList,
   getTempoString: () => getTempoString,
   getTuningStrings: () => getTuningStrings,
+  isNoteLength: () => isNoteLength,
+  isTupletRatio: () => isTupletRatio,
   validateGuitarNoteLabel: () => validateGuitarNoteLabel,
   validateHandedness: () => validateHandedness,
   validateIntervalQuality: () => validateIntervalQuality,
@@ -94,7 +96,7 @@ 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)) {
+  if (import_ts_utils_lib.Guard.isEnumValue(pn, PitchNotation)) {
     return pn;
   } else {
     throw new import_core.MusicError(import_core.MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
@@ -112,7 +114,7 @@ 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)) {
+  if (import_ts_utils_lib.Guard.isEnumValue(label, GuitarNoteLabel)) {
     return label;
   } else {
     throw new import_core.MusicError(import_core.MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
@@ -212,19 +214,32 @@ var _Note = class _Note {
    * @returns - Note.
    */
   static getNote(noteName) {
-    let note = this.noteByNameCache.get(noteName);
-    if (note === void 0) {
+    return this.noteCache.getOrCreate(noteName, () => {
       let p = _Note.parseNote(noteName);
-      if (!p) {
-        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid noteName: ${noteName}`);
-      }
-      if (p.octave === void 0) {
-        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Octave is required for note.`);
-      }
-      note = new _Note(p.noteLetter, p.accidental, p.octave);
-      this.noteByNameCache.set(noteName, note);
-    }
-    return note;
+      if (!p)
+        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note "${noteName}".`);
+      if (p.octave === void 0)
+        throw new import_core2.MusicError(import_core2.MusicErrorType.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 import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note "${noteName}"`);
   }
   /**
    * Get chromatic note. There are number of alternatives, this function uses simple logic to choose one.
@@ -232,21 +247,11 @@ var _Note = class _Note {
    * @returns - Note.
    */
   static getChromaticNote(chromaticId) {
-    let note = this.chromaticNoteCache.get(chromaticId);
-    if (note === void 0) {
+    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);
-      let p = _Note.parseNote(noteName);
-      if (!p) {
-        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid noteName: ${noteName}`);
-      }
-      if (p.octave === void 0) {
-        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Octave is required for note.`);
-      }
-      note = new _Note(p.noteLetter, p.accidental, p.octave);
-      this.chromaticNoteCache.set(chromaticId, note);
-    }
-    return note;
+      return _Note.getNote(noteName);
+    });
   }
   static getDiatonicClass(arg) {
     if (typeof arg === "number") {
@@ -415,7 +420,7 @@ var _Note = class _Note {
    * @returns - Valid diatonic id or throws.
    */
   static validateDiatonicId(diatonicId) {
-    if (import_ts_utils_lib2.Utils.Is.isInteger(diatonicId)) {
+    if (import_ts_utils_lib2.Guard.isInteger(diatonicId)) {
       return diatonicId;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid diatonicId: ${diatonicId}`);
@@ -427,7 +432,7 @@ var _Note = class _Note {
    * @returns - Valid diatonic class or throws.
    */
   static validateDiatonicClass(diatonicClass) {
-    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(diatonicClass, 0, 6)) {
+    if (import_ts_utils_lib2.Guard.isIntegerBetween(diatonicClass, 0, 6)) {
       return diatonicClass;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid diatonicClass: ${diatonicClass}`);
@@ -439,7 +444,7 @@ var _Note = class _Note {
    * @returns - Valid chromatic id, or throws.
    */
   static validateChromaticId(chromaticId) {
-    if (import_ts_utils_lib2.Utils.Is.isInteger(chromaticId)) {
+    if (import_ts_utils_lib2.Guard.isInteger(chromaticId)) {
       return chromaticId;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid chromaticId: ${chromaticId}`);
@@ -451,7 +456,7 @@ var _Note = class _Note {
    * @returns - Valid chromatic class, or throws.
    */
   static validatechromaticClass(chromaticClass) {
-    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(chromaticClass, 0, 11)) {
+    if (import_ts_utils_lib2.Guard.isIntegerBetween(chromaticClass, 0, 11)) {
       return chromaticClass;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid chromaticClass: ${chromaticClass}`);
@@ -475,7 +480,7 @@ var _Note = class _Note {
    * @returns - Valid octave or throws.
    */
   static validateOctave(octave) {
-    if (import_ts_utils_lib2.Utils.Is.isInteger(octave)) {
+    if (import_ts_utils_lib2.Guard.isInteger(octave)) {
       return octave;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid octave: ${octave}`);
@@ -487,7 +492,7 @@ var _Note = class _Note {
    * @returns - Valid accidental or thorws.
    */
   static validateAccidental(acc) {
-    if (import_ts_utils_lib2.Utils.Is.isIntegerBetween(acc, -2, 2)) {
+    if (import_ts_utils_lib2.Guard.isIntegerBetween(acc, -2, 2)) {
       return acc;
     } else {
       throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid accidental: ${acc}`);
@@ -537,8 +542,8 @@ var _Note = class _Note {
     }
   }
 };
-__publicField(_Note, "noteByNameCache", /* @__PURE__ */ new Map());
-__publicField(_Note, "chromaticNoteCache", /* @__PURE__ */ new Map());
+__publicField(_Note, "noteCache", new import_ts_utils_lib2.UniMap());
+__publicField(_Note, "chromaticNoteCache", new import_ts_utils_lib2.UniMap());
 var Note = _Note;
 
 // src/theory/scale.ts
@@ -566,7 +571,7 @@ function parseDegree(degree) {
   }
   let acc = (_b = Note.getAccidental((_a = m[1]) != null ? _a : "")) != null ? _b : 0;
   let deg = +m[2];
-  if (!import_ts_utils_lib3.Utils.Is.isInteger(acc) || acc < -2 || acc > 2 || !import_ts_utils_lib3.Utils.Is.isInteger(deg) || deg < 1) {
+  if (!import_ts_utils_lib3.Guard.isInteger(acc) || acc < -2 || acc > 2 || !import_ts_utils_lib3.Guard.isInteger(deg) || deg < 1) {
     throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, `Invalid degree: ${degree}`);
   } else {
     return { deg, acc };
@@ -602,7 +607,7 @@ var _KeySignature = class _KeySignature {
     __publicField(this, "naturalScaleNotes");
     __publicField(this, "accidentalByDiatonicClass");
     __publicField(this, "orderedAccidentedNotes");
-    if (!import_ts_utils_lib3.Utils.Is.isEnumValue(mode, Mode)) {
+    if (!import_ts_utils_lib3.Guard.isEnumValue(mode, Mode)) {
       throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, `Invalid mode: ${mode}`);
     }
     let intervals = [2, 2, 1, 2, 2, 2, 1];
@@ -722,7 +727,7 @@ var KeySignature = _KeySignature;
 // src/theory/interval.ts
 var import_ts_utils_lib4 = require("@tspro/ts-utils-lib");
 var import_core4 = require("@tspro/web-music-score/core");
-var IntervalQualityAbbrMap = /* @__PURE__ */ new Map([
+var IntervalQualityAbbrMap = new import_ts_utils_lib4.UniMap([
   ["Major", "M"],
   ["minor", "m"],
   ["Perfect", "P"],
@@ -825,7 +830,7 @@ function validateIntervalQuality(q) {
   }
 }
 function formatQuantity(q) {
-  if (!import_ts_utils_lib4.Utils.Is.isIntegerGte(q, 1)) {
+  if (!import_ts_utils_lib4.Guard.isIntegerGte(q, 1)) {
     throw new import_core4.MusicError(import_core4.MusicErrorType.InvalidArg, `Invalid interval quantity: ${q}`);
   } else {
     return import_ts_utils_lib4.Utils.Math.toOrdinalNumber(q);
@@ -898,9 +903,8 @@ var Interval = class _Interval {
    * @returns - Interval abbrevated string.
    */
   toAbbrString() {
-    var _a;
     let direction = this.direction === "Descending" ? "\u2193" : "";
-    let quality = (_a = IntervalQualityAbbrMap.get(this.quality)) != null ? _a : "?";
+    let quality = IntervalQualityAbbrMap.getOrDefault(this.quality, "?");
     let quantity = this.quantity;
     return direction + quality + quantity;
   }
@@ -1006,7 +1010,7 @@ var Scale = class extends KeySignature {
     __publicField(this, "scaleNotes");
     /** Degrees (or undefined) of chromatic classes. */
     __publicField(this, "chromaticClassDegree");
-    __publicField(this, "preferredChromaticNoteCache", /* @__PURE__ */ new Map());
+    __publicField(this, "preferredChromaticIdNoteCache", new import_ts_utils_lib5.SignedIndexArray());
     switch (scaleType) {
       case "Harmonic Minor" /* HarmonicMinor */:
         this.scaleDegrees = [1, 2, 3, 4, 5, 6, "#7"];
@@ -1071,7 +1075,7 @@ var Scale = class extends KeySignature {
    * @returns - Array of scale notes.
    */
   getScaleNotes(bottomNote, numOctaves) {
-    if (!import_ts_utils_lib5.Utils.Is.isIntegerGte(numOctaves, 1)) {
+    if (!import_ts_utils_lib5.Guard.isIntegerGte(numOctaves, 1)) {
       throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid numOctaves: ${numOctaves}`);
     }
     let scaleNoteList = [];
@@ -1147,6 +1151,7 @@ var Scale = class extends KeySignature {
       return interval;
     }
   }
+  // Can it be negative case?
   /**
    * Get preferred chromatic note from given chromatic id.
    * @param chromaticId - Chromatic id.
@@ -1154,7 +1159,7 @@ var Scale = class extends KeySignature {
    */
   getPreferredChromaticNote(chromaticId) {
     Note.validateChromaticId(chromaticId);
-    let note = this.preferredChromaticNoteCache.get(chromaticId);
+    let note = this.preferredChromaticIdNoteCache.get(chromaticId);
     if (note) {
       return note;
     }
@@ -1170,7 +1175,7 @@ var Scale = class extends KeySignature {
     });
     note = scaleNotes.find((note2) => Note.getChromaticClass(chromaticId) === note2.chromaticClass);
     if (note) {
-      this.preferredChromaticNoteCache.set(chromaticId, note);
+      this.preferredChromaticIdNoteCache.set(chromaticId, note);
       return note;
     }
     let diatonicIdMid = getNaturalDiatonicId(chromaticId);
@@ -1183,13 +1188,13 @@ var Scale = class extends KeySignature {
       for (let diatonicId = Math.max(0, diatonicIdStart); diatonicId <= diatonicIdEnd; diatonicId++) {
         note = new Note(diatonicId, acc);
         if (chromaticId === note.chromaticId) {
-          this.preferredChromaticNoteCache.set(chromaticId, note);
+          this.preferredChromaticIdNoteCache.set(chromaticId, note);
           return note;
         }
       }
     }
     note = Note.getChromaticNote(chromaticId);
-    this.preferredChromaticNoteCache.set(chromaticId, note);
+    this.preferredChromaticIdNoteCache.set(chromaticId, note);
     return note;
   }
 };
@@ -1309,7 +1314,7 @@ var ScaleFactoryList = [
 function getScaleFactoryList() {
   return ScaleFactoryList;
 }
-var ScaleFactoryMap = /* @__PURE__ */ new Map();
+var ScaleFactoryMap = new import_ts_utils_lib5.UniMap();
 ScaleFactoryList.forEach((factory) => {
   if (factory instanceof ScaleFactory) {
     ScaleFactoryMap.set(factory.getType(), factory);
@@ -1324,7 +1329,7 @@ function getScaleFactory(scaleType) {
   }
 }
 function validateScaleType(scaleType) {
-  if (import_ts_utils_lib5.Utils.Is.isEnumValue(scaleType, ScaleType)) {
+  if (import_ts_utils_lib5.Guard.isEnumValue(scaleType, ScaleType)) {
     return scaleType;
   } else {
     throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: "${scaleType}"`);
@@ -1368,18 +1373,15 @@ var OkayRootNoteList = [
   "B",
   "Cb"
 ].map((noteName) => Note.getNote(noteName + "0"));
-var okayRootNoteCache = /* @__PURE__ */ new Map();
+var okayRootNoteCache = new import_ts_utils_lib6.IndexArray();
 function getOkayRootNote(wantedRootNote) {
-  let cacheKey = wantedRootNote.chromaticClass;
-  let rootNote = okayRootNoteCache.get(cacheKey);
-  if (!rootNote) {
-    rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
+  return okayRootNoteCache.getOrCreate(wantedRootNote.chromaticClass, () => {
+    let rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
     if (!rootNote) {
       throw new import_core6.MusicError(import_core6.MusicErrorType.InvalidArg, `Invalid chord root note: ${wantedRootNote.formatOmitOctave(1 /* Unicode */)}`);
     }
-    okayRootNoteCache.set(cacheKey, rootNote);
-  }
-  return rootNote;
+    return rootNote;
+  });
 }
 function getChordNoteByDegree(chordRootNote, degree) {
   let chordRootNoteStr = chordRootNote.formatOmitOctave(0 /* Ascii */);
@@ -1387,7 +1389,7 @@ function getChordNoteByDegree(chordRootNote, degree) {
   return ks.getNoteByDegree(degree);
 }
 function removeNoteDuplicates(notes) {
-  return import_ts_utils_lib6.Utils.Arr.removeDuplicatesCmp(notes, isEqualNote);
+  return import_ts_utils_lib6.Utils.Arr.removeDuplicates(notes, isEqualNote);
 }
 var ChordInfoList = [
   // Power chord
@@ -1844,7 +1846,7 @@ var Handedness = /* @__PURE__ */ ((Handedness2) => {
 })(Handedness || {});
 var DefaultHandedness = 0 /* RightHanded */;
 function validateHandedness(h) {
-  if (import_ts_utils_lib7.Utils.Is.isEnumValue(h, Handedness)) {
+  if (import_ts_utils_lib7.Guard.isEnumValue(h, Handedness)) {
     return h;
   } else {
     throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid handedness: ${h}`);
@@ -1868,7 +1870,7 @@ function getTuningStrings(tuningName) {
       throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid tuningName: ${tuningName}`);
     }
     tuningStrings = tuningData.strings.slice().reverse().map((noteName) => Note.getNote(noteName));
-    if (!import_ts_utils_lib7.Utils.Is.isIntegerEq(tuningStrings.length, 6)) {
+    if (!import_ts_utils_lib7.Guard.isIntegerEq(tuningStrings.length, 6)) {
       throw new import_core7.MusicError(import_core7.MusicErrorType.Unknown, `Tuning has ${tuningStrings.length} strings.`);
     }
     TuningStringsCache.set(tuningName, tuningStrings);
@@ -1923,8 +1925,11 @@ var NoteLength = /* @__PURE__ */ ((NoteLength3) => {
   NoteLength3["SixtyFourthTriplet"] = "64t";
   return NoteLength3;
 })(NoteLength || {});
+function isNoteLength(noteLength) {
+  return import_ts_utils_lib8.Guard.isEnumValue(noteLength, NoteLength);
+}
 function validateNoteLength(noteLength) {
-  if (import_ts_utils_lib8.Utils.Is.isEnumValue(noteLength, NoteLength)) {
+  if (isNoteLength(noteLength)) {
     return noteLength;
   } else {
     throw new import_core8.MusicError(import_core8.MusicErrorType.InvalidArg, `Invalid noteLength: ${noteLength}`);
@@ -1971,11 +1976,7 @@ var _NoteLengthProps = class _NoteLengthProps {
    * @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;
+    return this.cache.getOrCreate(noteLength, () => new _NoteLengthProps(noteLength));
   }
   /**
    * Create note length props.
@@ -1985,7 +1986,7 @@ var _NoteLengthProps = class _NoteLengthProps {
    */
   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"));
+    return this.get(noteSize + (import_ts_utils_lib8.Guard.isIntegerGte(dotCount, 1) ? ".".repeat(dotCount) : "n"));
   }
   /**
    * Compare note lengths/sizes. Whole (1) > half (2) > quarter (4), etc.
@@ -2016,10 +2017,13 @@ var _NoteLengthProps = class _NoteLengthProps {
 __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());
+__publicField(_NoteLengthProps, "cache", new import_ts_utils_lib8.UniMap());
 var NoteLengthProps = _NoteLengthProps;
+function isTupletRatio(tupletRatio) {
+  return import_ts_utils_lib8.Guard.isObject(tupletRatio) && import_ts_utils_lib8.Guard.isIntegerBetween(tupletRatio.parts, 2, MaxTupletRatioValue) && import_ts_utils_lib8.Guard.isIntegerBetween(tupletRatio.inTimeOf, 2, MaxTupletRatioValue);
+}
 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)) {
+  if (isTupletRatio(tupletRatio)) {
     return tupletRatio;
   } else {
     throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Invalid tupletRatio ${JSON.stringify(tupletRatio)}`);
@@ -2059,7 +2063,7 @@ var _RhythmProps = class _RhythmProps {
     this.dotCount = dotCount != null ? dotCount : p.dotCount;
     this.hasStem = p.hasStem;
     this.isSolidNoteHead = p.isSolid;
-    if (import_ts_utils_lib8.Utils.Is.isObject(tupletRatio)) {
+    if (import_ts_utils_lib8.Guard.isObject(tupletRatio)) {
       this.tupletRatio = validateTupletRatio(tupletRatio);
     } else if (p.isTriplet) {
       this.tupletRatio = Tuplet.Triplet;
@@ -2098,11 +2102,7 @@ var _RhythmProps = class _RhythmProps {
     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;
+      return this.cache.getOrCreate(noteLength, () => new _RhythmProps(noteLength));
     }
   }
   /**
@@ -2124,8 +2124,8 @@ var _RhythmProps = class _RhythmProps {
     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());
+__publicField(_RhythmProps, "NoteSymbolMap", new import_ts_utils_lib8.IndexArray([[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", new import_ts_utils_lib8.UniMap());
 var RhythmProps = _RhythmProps;
 
 // src/theory/time-signature.ts
@@ -2162,25 +2162,25 @@ var TimeSignature = class {
     /** Beam groups (e.g. [[2], [2]] or [[2, 2], [2, 2]] (first try as [[4], [4]])). */
     __publicField(this, "beamGroupSizes", []);
     let beamGrouping;
-    if (import_ts_utils_lib9.Utils.Is.isEnumValue(args[0], TimeSignatures)) {
+    if (import_ts_utils_lib9.Guard.isEnumValue(args[0], TimeSignatures)) {
       let parts = args[0].split("/");
       this.beatCount = +parts[0];
       this.beatSize = +parts[1];
-      if (import_ts_utils_lib9.Utils.Is.isEnumValue(args[1], BeamGrouping)) {
+      if (import_ts_utils_lib9.Guard.isEnumValue(args[1], BeamGrouping)) {
         beamGrouping = args[1];
       }
-    } else if (import_ts_utils_lib9.Utils.Is.isIntegerGte(args[0], 2) && import_ts_utils_lib9.Utils.Is.isIntegerGte(args[1], 2)) {
+    } else if (import_ts_utils_lib9.Guard.isIntegerGte(args[0], 2) && import_ts_utils_lib9.Guard.isIntegerGte(args[1], 2)) {
       this.beatCount = args[0];
       this.beatSize = args[1];
-      if (import_ts_utils_lib9.Utils.Is.isEnumValue(args[2], BeamGrouping)) {
+      if (import_ts_utils_lib9.Guard.isEnumValue(args[2], BeamGrouping)) {
         beamGrouping = args[2];
       }
     } else {
       throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid args: ${args}`);
     }
-    if (!import_ts_utils_lib9.Utils.Is.isIntegerGte(this.beatCount, 1)) {
+    if (!import_ts_utils_lib9.Guard.isIntegerGte(this.beatCount, 1)) {
       throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beatCount: ${this.beatCount}`);
-    } else if (!import_ts_utils_lib9.Utils.Is.isIntegerGte(this.beatSize, 1)) {
+    } else if (!import_ts_utils_lib9.Guard.isIntegerGte(this.beatSize, 1)) {
       throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beatSize: ${this.beatSize}`);
     }
     let { noteLength, ticks } = NoteLengthProps.create(this.beatSize);
@@ -2195,7 +2195,7 @@ var TimeSignature = class {
     } else if (this.is(3, 8)) {
       this.beamGroupSizes = [[3]];
     } else if (this.is(5, 8)) {
-      if (!import_ts_utils_lib9.Utils.Is.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
+      if (!import_ts_utils_lib9.Guard.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
         throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
       } else {
         this.beamGroupSizes = beamGrouping === "3-2" /* _3_2 */ ? [[3], [2]] : [[2], [3]];
@@ -2204,7 +2204,7 @@ var TimeSignature = class {
     } else if (this.is(6, 8)) {
       this.beamGroupSizes = [[3], [3]];
     } else if (this.is(7, 8)) {
-      if (!import_ts_utils_lib9.Utils.Is.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
+      if (!import_ts_utils_lib9.Guard.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
         throw new import_core9.MusicError(import_core9.MusicErrorType.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]];
@@ -2307,6 +2307,8 @@ var import_core10 = require("@tspro/web-music-score/core");
   getScaleFactoryList,
   getTempoString,
   getTuningStrings,
+  isNoteLength,
+  isTupletRatio,
   validateGuitarNoteLabel,
   validateHandedness,
   validateIntervalQuality,