@tspro/web-music-score 3.2.0 → 4.0.0

package/dist/theory/index.mjs

@@ -1,7 +1,7 @@
-/* WebMusicScore v3.2.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
+/* WebMusicScore v4.0.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
 import {
   __publicField
-} from "../chunk-LCTM7BID.mjs";
+} from "../chunk-D643HZHM.mjs";
 
 // src/theory/chord.ts
 import { Utils as Utils6 } from "@tspro/ts-utils-lib";
@@ -25,10 +25,10 @@ var PitchNotation = /* @__PURE__ */ ((PitchNotation2) => {
 var PitchNotationList = Utils.Enum.getEnumValues(PitchNotation);
 var DefaultPitchNotation = 0 /* Scientific */;
 function validatePitchNotation(pn) {
-  if (!Utils.Is.isEnumValue(pn, PitchNotation)) {
-    throw new MusicError(MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
-  } else {
+  if (Utils.Is.isEnumValue(pn, PitchNotation)) {
     return pn;
+  } else {
+    throw new MusicError(MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
   }
 }
 function getPitchNotationName(pn) {
@@ -43,10 +43,10 @@ var GuitarNoteLabel = /* @__PURE__ */ ((GuitarNoteLabel2) => {
 var DefaultGuitarNoteLabel = "Default" /* Default */;
 var GuitarNoteLabelList = Utils.Enum.getEnumValues(GuitarNoteLabel);
 function validateGuitarNoteLabel(label) {
-  if (!Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
-    throw new MusicError(MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
-  } else {
+  if (Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
     return label;
+  } else {
+    throw new MusicError(MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
   }
 }
 
@@ -982,10 +982,19 @@ function validateScaleType(scaleType) {
   if (Utils5.Is.isEnumValue(scaleType, ScaleType)) {
     return scaleType;
   } else {
-    throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: ${scaleType}`);
+    throw new MusicError5(MusicErrorType5.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 */);
@@ -1476,10 +1485,10 @@ var Handedness = /* @__PURE__ */ ((Handedness2) => {
 })(Handedness || {});
 var DefaultHandedness = 0 /* RightHanded */;
 function validateHandedness(h) {
-  if (!Utils7.Is.isEnumValue(h, Handedness)) {
-    throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid handedness: ${h}`);
-  } else {
+  if (Utils7.Is.isEnumValue(h, Handedness)) {
     return h;
+  } else {
+    throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid handedness: ${h}`);
   }
 }
 var TuningNameList = tunings_default.list.map((data) => data.name);
@@ -1514,81 +1523,213 @@ import { Utils as Utils9 } from "@tspro/ts-utils-lib";
 // src/theory/rhythm.ts
 import { Utils as Utils8 } from "@tspro/ts-utils-lib";
 import { MusicError as MusicError8, MusicErrorType as MusicErrorType8 } from "@tspro/web-music-score/core";
+var 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["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 (!Utils8.Is.isEnumValue(noteLength, NoteLength)) {
+  if (Utils8.Is.isEnumValue(noteLength, NoteLength)) {
+    return noteLength;
+  } else {
     throw new MusicError8(MusicErrorType8.InvalidArg, `Invalid noteLength: ${noteLength}`);
+  }
+}
+var _NoteLengthProps = class _NoteLengthProps {
+  // Is solid (black) note head?
+  constructor(noteLength) {
+    __publicField(this, "noteLength");
+    __publicField(this, "noteSize");
+    __publicField(this, "ticks");
+    // Not altered by isTriplet!
+    __publicField(this, "flagCount");
+    __publicField(this, "dotCount");
+    __publicField(this, "maxDotCount");
+    __publicField(this, "isTriplet");
+    __publicField(this, "hasStem");
+    __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 = Utils8.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 MusicError8(MusicErrorType8.Note, `dotCount ${this.dotCount} > maxDotCount ${this.maxDotCount}, for noteLength "${this.noteLength}".`);
+    } else if (this.isTriplet && this.dotCount > 0) {
+      throw new MusicError8(MusicErrorType8.Note, `noteLength "${this.noteLength}" is both triplet and dotted!`);
+    }
+  }
+  static get(noteLength) {
+    let p = this.cache.get(noteLength);
+    if (!p) {
+      this.cache.set(noteLength, p = new _NoteLengthProps(noteLength));
+    }
+    return p;
+  }
+  static create(noteLength, dotCount = 0) {
+    let noteSize = typeof noteLength === "number" ? noteLength : this.get(noteLength).noteSize;
+    return this.get(noteSize + (Utils8.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;
+  }
+};
+__publicField(_NoteLengthProps, "LongestNoteSize", Math.min(...Utils8.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+__publicField(_NoteLengthProps, "ShortestNoteSize", Math.max(...Utils8.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+__publicField(_NoteLengthProps, "cache", /* @__PURE__ */ new Map());
+var NoteLengthProps = _NoteLengthProps;
+function validateTupletRatio(tupletRatio) {
+  if (Utils8.Is.isObject(tupletRatio) && Utils8.Is.isIntegerBetween(tupletRatio.parts, 2, MaxTupletRatioValue) && Utils8.Is.isIntegerBetween(tupletRatio.inTimeOf, 2, MaxTupletRatioValue)) {
+    return tupletRatio;
   } else {
-    return noteLength;
+    throw new MusicError8(MusicErrorType8.Note, `Invalid tupletRatio ${JSON.stringify(tupletRatio)}`);
   }
 }
-var RhythmProps = class _RhythmProps {
-  constructor(noteLength, dotted, triplet) {
+var Tuplet = {
+  /** 2 in the time of 3 */
+  Duplet: { parts: 2, inTimeOf: 3 },
+  /** 3 in the time of 2 */
+  Triplet: { parts: 3, inTimeOf: 2 },
+  /** 4 in the time of 3 */
+  Quadruplet: { parts: 4, inTimeOf: 3 }
+};
+var _RhythmProps = class _RhythmProps {
+  constructor(noteLength, dotCount, tupletRatio) {
     __publicField(this, "noteLength");
-    __publicField(this, "dotted");
-    __publicField(this, "triplet");
+    __publicField(this, "noteSize");
+    // whole=1, half=2, quarter=4, etc.
+    __publicField(this, "dotCount");
+    __publicField(this, "tupletRatio");
     __publicField(this, "ticks");
     __publicField(this, "flagCount");
-    var _a;
+    __publicField(this, "hasStem");
+    __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 MusicError8(MusicErrorType8.Note, "Note cannot be both dotted and triplet!");
-    } else if (this.dotted && this.noteLength === MinNoteLength) {
-      throw new MusicError8(MusicErrorType8.Note, "Shortest note cannot be dotted!");
+    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 (Utils8.Is.isObject(tupletRatio)) {
+      this.tupletRatio = validateTupletRatio(tupletRatio);
+    } else if (p.isTriplet) {
+      this.tupletRatio = Tuplet.Triplet;
+    } else {
+      this.tupletRatio = void 0;
     }
-    if (this.dotted) {
-      this.ticks += this.noteLength / 2;
+    if (this.dotCount > 0 && this.tupletRatio !== void 0) {
+      throw new MusicError8(MusicErrorType8.Note, `Note cannot be both dotted and tuplet!`);
+    } else if (this.dotCount > p.maxDotCount) {
+      throw new MusicError8(MusicErrorType8.Note, `Too big dot count ${this.dotCount} for note length ${this.noteLength}.`);
     }
-    if (this.triplet) {
-      this.ticks = this.ticks * 2 / 3;
+    for (let add = this.ticks / 2, i = 1; i <= this.dotCount; i++, add /= 2) {
+      this.ticks += add;
+    }
+    if (this.tupletRatio) {
+      this.ticks *= this.tupletRatio.inTimeOf / this.tupletRatio.parts;
     }
   }
-  static createFromNoteSize(noteSize) {
-    return new _RhythmProps(MaxNoteLength / noteSize);
+  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;
+  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
 import { MusicError as MusicError9, MusicErrorType as MusicErrorType9 } from "@tspro/web-music-score/core";
@@ -1616,9 +1757,9 @@ var TimeSignature = class {
     } else if (!Utils9.Is.isIntegerGte(this.beatSize, 1)) {
       throw new MusicError9(MusicErrorType9.Timesignature, `Invalid beatSize: ${this.beatSize}`);
     }
-    let beatLengthValue = RhythmProps.createFromNoteSize(this.beatSize);
-    this.beatLength = beatLengthValue.noteLength;
-    this.measureTicks = this.beatCount * beatLengthValue.ticks;
+    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)) {
@@ -1651,17 +1792,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 }
   };
 }
 
@@ -1680,11 +1821,10 @@ export {
   Handedness,
   Interval,
   KeySignature,
-  MaxNoteLength,
-  MinNoteLength,
   Mode,
   Note,
   NoteLength,
+  NoteLengthProps,
   PitchNotation,
   PitchNotationList,
   RhythmProps,
@@ -1694,6 +1834,7 @@ export {
   SymbolSet,
   TimeSignature,
   TuningNameList,
+  Tuplet,
   alterTempoSpeed,
   getDefaultKeySignature,
   getDefaultScale,
@@ -1711,6 +1852,7 @@ export {
   validateNoteLength,
   validatePitchNotation,
   validateScaleType,
-  validateTuningName
+  validateTuningName,
+  validateTupletRatio
 };
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tspro/web-music-score",
-    "version": "3.2.0",
+    "version": "4.0.0",
     "author": "PahkaSoft",
     "license": "MIT",
     "private": false,
@@ -92,7 +92,7 @@
         "package.json"
     ],
     "dependencies": {
-        "@tspro/ts-utils-lib": "^1.3.0",
+        "@tspro/ts-utils-lib": "^1.6.0",
         "tone": "^15.1.22"
     },
     "peerDependencies": {

package/dist/tempo-B4h5Ktob.d.mts

@@ -1,104 +0,0 @@
-import { N as Note, A as Accidental } from './note-BFa43I86.mjs';
-
-declare enum Mode {
-    Ionian = 1,
-    Dorian = 2,
-    Phrygian = 3,
-    Lydian = 4,
-    Mixolydian = 5,
-    Aeolian = 6,
-    Locrian = 7
-}
-declare enum AccidentalType {
-    Natural = 0,
-    Flats = 1,
-    Sharps = 2
-}
-declare function getDefaultKeySignature(): KeySignature;
-declare class KeySignature {
-    readonly tonic: string;
-    readonly mode: Mode;
-    private static readonly OrderOfSharps;
-    private static readonly OrderOfFlats;
-    private readonly naturalScaleNotes;
-    private readonly accidentalByDiatonicClass;
-    private readonly orderedAccidentedNotes;
-    /**
-     * @param tonic - Tonic/root note.
-     * @param mode - Mode: Ionian/Major = 1, Dorian = 2, ..., Locrian = 7
-     */
-    protected constructor(tonic: string, mode: Mode);
-    getAccidentalType(): AccidentalType;
-    getNaturalScaleNotes(): ReadonlyArray<Note>;
-    getAccidental(diatonicId: number): Accidental;
-    getNumAccidentals(): number;
-    getOrderedAccidentalNotes(): ReadonlyArray<Note>;
-    /**
-     *
-     * @param degree - number 1..7 or string e.g "b5" or "#4"
-     * @returns
-     */
-    getNoteByDegree(degree: number | string): Note;
-    static equals(a: KeySignature | null | undefined, b: KeySignature | null | undefined): boolean;
-}
-
-declare enum NoteLength {
-    Whole = 192,// * 3 because triplets are multiplied by 2 / 3, integer result
-    Half = 96,
-    Quarter = 48,
-    Eighth = 24,
-    Sixteenth = 12,
-    ThirtySecond = 6,
-    SixtyFourth = 3
-}
-declare const MaxNoteLength = NoteLength.Whole;
-declare const MinNoteLength = NoteLength.SixtyFourth;
-declare function validateNoteLength(noteLength: unknown): NoteLength;
-declare class RhythmProps {
-    readonly noteLength: NoteLength;
-    readonly dotted: boolean;
-    readonly triplet: boolean;
-    readonly ticks: number;
-    readonly flagCount: number;
-    constructor(noteLength: NoteLength, dotted?: boolean, triplet?: boolean);
-    static createFromNoteSize(noteSize: number): RhythmProps;
-    canDot(): boolean;
-    hasStem(): boolean;
-    toString(): string;
-}
-
-type TimeSignatureString = "2/4" | "3/4" | "4/4" | "6/8" | "9/8";
-declare class TimeSignature {
-    readonly beatCount: number;
-    readonly beatSize: number;
-    /** Lengths in ticks */
-    readonly beatLength: NoteLength;
-    readonly measureTicks: number;
-    readonly beamGroupCount: number;
-    readonly beamGroupLength: number;
-    /**
-     * @param str - For example "4/4".
-     */
-    constructor(str: TimeSignatureString);
-    /**
-     * @param beatCount - Measure beat count.
-     * @param beatSize - Size value: whole-note=1, half-note=2, quarter-note=4, etc.
-     */
-    constructor(beatCount: number, beatSize: number);
-    is(beatCount: number, beatSize: number): boolean;
-    toString(): string;
-}
-declare function getDefaultTimeSignature(): TimeSignature;
-
-type Tempo = {
-    beatsPerMinute: number;
-    options: {
-        beatLength: NoteLength;
-        dotted: boolean;
-    };
-};
-declare function getDefaultTempo(): Readonly<Tempo>;
-declare function getTempoString(tempo: Tempo): string;
-declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
-
-export { AccidentalType as A, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, type TimeSignatureString as T, TimeSignature as a, getDefaultTimeSignature as b, type Tempo as c, getDefaultTempo as d, getTempoString as e, alterTempoSpeed as f, getDefaultKeySignature as g, MaxNoteLength as h, MinNoteLength as i, validateNoteLength as v };

package/dist/tempo-DgqDEsn0.d.ts

@@ -1,104 +0,0 @@
-import { N as Note, A as Accidental } from './note-BFa43I86.js';
-
-declare enum Mode {
-    Ionian = 1,
-    Dorian = 2,
-    Phrygian = 3,
-    Lydian = 4,
-    Mixolydian = 5,
-    Aeolian = 6,
-    Locrian = 7
-}
-declare enum AccidentalType {
-    Natural = 0,
-    Flats = 1,
-    Sharps = 2
-}
-declare function getDefaultKeySignature(): KeySignature;
-declare class KeySignature {
-    readonly tonic: string;
-    readonly mode: Mode;
-    private static readonly OrderOfSharps;
-    private static readonly OrderOfFlats;
-    private readonly naturalScaleNotes;
-    private readonly accidentalByDiatonicClass;
-    private readonly orderedAccidentedNotes;
-    /**
-     * @param tonic - Tonic/root note.
-     * @param mode - Mode: Ionian/Major = 1, Dorian = 2, ..., Locrian = 7
-     */
-    protected constructor(tonic: string, mode: Mode);
-    getAccidentalType(): AccidentalType;
-    getNaturalScaleNotes(): ReadonlyArray<Note>;
-    getAccidental(diatonicId: number): Accidental;
-    getNumAccidentals(): number;
-    getOrderedAccidentalNotes(): ReadonlyArray<Note>;
-    /**
-     *
-     * @param degree - number 1..7 or string e.g "b5" or "#4"
-     * @returns
-     */
-    getNoteByDegree(degree: number | string): Note;
-    static equals(a: KeySignature | null | undefined, b: KeySignature | null | undefined): boolean;
-}
-
-declare enum NoteLength {
-    Whole = 192,// * 3 because triplets are multiplied by 2 / 3, integer result
-    Half = 96,
-    Quarter = 48,
-    Eighth = 24,
-    Sixteenth = 12,
-    ThirtySecond = 6,
-    SixtyFourth = 3
-}
-declare const MaxNoteLength = NoteLength.Whole;
-declare const MinNoteLength = NoteLength.SixtyFourth;
-declare function validateNoteLength(noteLength: unknown): NoteLength;
-declare class RhythmProps {
-    readonly noteLength: NoteLength;
-    readonly dotted: boolean;
-    readonly triplet: boolean;
-    readonly ticks: number;
-    readonly flagCount: number;
-    constructor(noteLength: NoteLength, dotted?: boolean, triplet?: boolean);
-    static createFromNoteSize(noteSize: number): RhythmProps;
-    canDot(): boolean;
-    hasStem(): boolean;
-    toString(): string;
-}
-
-type TimeSignatureString = "2/4" | "3/4" | "4/4" | "6/8" | "9/8";
-declare class TimeSignature {
-    readonly beatCount: number;
-    readonly beatSize: number;
-    /** Lengths in ticks */
-    readonly beatLength: NoteLength;
-    readonly measureTicks: number;
-    readonly beamGroupCount: number;
-    readonly beamGroupLength: number;
-    /**
-     * @param str - For example "4/4".
-     */
-    constructor(str: TimeSignatureString);
-    /**
-     * @param beatCount - Measure beat count.
-     * @param beatSize - Size value: whole-note=1, half-note=2, quarter-note=4, etc.
-     */
-    constructor(beatCount: number, beatSize: number);
-    is(beatCount: number, beatSize: number): boolean;
-    toString(): string;
-}
-declare function getDefaultTimeSignature(): TimeSignature;
-
-type Tempo = {
-    beatsPerMinute: number;
-    options: {
-        beatLength: NoteLength;
-        dotted: boolean;
-    };
-};
-declare function getDefaultTempo(): Readonly<Tempo>;
-declare function getTempoString(tempo: Tempo): string;
-declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
-
-export { AccidentalType as A, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, type TimeSignatureString as T, TimeSignature as a, getDefaultTimeSignature as b, type Tempo as c, getDefaultTempo as d, getTempoString as e, alterTempoSpeed as f, getDefaultKeySignature as g, MaxNoteLength as h, MinNoteLength as i, validateNoteLength as v };