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

package/dist/audio-synth/index.mjs

@@ -0,0 +1,63 @@
+/* WebMusicScore v6.0.0-pre.1 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+import {
+  Filter,
+  PolySynth,
+  Reverb,
+  Synth
+} from "../chunk-LO4NI4AU.mjs";
+import {
+  linearToDecibels
+} from "../chunk-VHB57TXT.mjs";
+import {
+  __publicField
+} from "../chunk-A7C2G7OG.mjs";
+
+// src/audio-instruments/audio-synth/index.ts
+var SynthesizerInstr = class {
+  constructor() {
+    __publicField(this, "audioSource");
+    try {
+      const reverb = new Reverb({ decay: 3, wet: 0.4 }).toDestination();
+      const filter = new Filter(800, "lowpass").connect(reverb);
+      this.audioSource = new PolySynth(Synth, {
+        oscillator: {
+          type: "triangle"
+        },
+        envelope: {
+          attack: 1e-3,
+          decay: 2,
+          sustain: 0.1,
+          release: 1.2
+        }
+      }).connect(filter);
+    } catch (err) {
+      this.audioSource = void 0;
+      console.error(err);
+    }
+  }
+  getName() {
+    return "Synthesizer";
+  }
+  playNote(note, duration, linearVolume) {
+    try {
+      if (this.audioSource) {
+        this.audioSource.volume.value = linearToDecibels(linearVolume);
+        this.audioSource.triggerAttackRelease(note, duration);
+      }
+    } catch (err) {
+    }
+  }
+  stop() {
+    try {
+      if (this.audioSource) {
+        this.audioSource.releaseAll();
+      }
+    } catch (err) {
+    }
+  }
+};
+var Synthesizer = new SynthesizerInstr();
+export {
+  Synthesizer
+};
+//# sourceMappingURL=index.mjs.map

package/dist/chunk-A7C2G7OG.mjs

@@ -0,0 +1,101 @@
+/* WebMusicScore v6.0.0-pre.1 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+export {
+  __pow,
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __publicField,
+  __async,
+  __yieldStar
+};
+//# sourceMappingURL=chunk-A7C2G7OG.mjs.map

package/dist/chunk-GNT3ECDB.mjs

@@ -0,0 +1,267 @@
+/* WebMusicScore v6.0.0-pre.1 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+import {
+  IndexArray,
+  UniMap,
+  guard_exports,
+  utils_exports
+} from "./chunk-X7BMJX7E.mjs";
+import {
+  __publicField
+} from "./chunk-A7C2G7OG.mjs";
+
+// src/theory/rhythm.ts
+import { MusicError, MusicErrorType } from "web-music-score/core";
+var MaxTupletRatioValue = 12;
+var TicksMultiplier = 12 * 11 * 9 * 7 * 5;
+var NoteLength = /* @__PURE__ */ ((NoteLength2) => {
+  NoteLength2["Whole"] = "1n";
+  NoteLength2["WholeTriplet"] = "1t";
+  NoteLength2["WholeDot"] = "1.";
+  NoteLength2["Whole2Dots"] = "1..";
+  NoteLength2["Whole3Dots"] = "1...";
+  NoteLength2["Whole4Dots"] = "1....";
+  NoteLength2["Whole5Dots"] = "1.....";
+  NoteLength2["Whole6Dots"] = "1......";
+  NoteLength2["Half"] = "2n";
+  NoteLength2["HalfTriplet"] = "2t";
+  NoteLength2["HalfDot"] = "2.";
+  NoteLength2["Half2Dots"] = "2..";
+  NoteLength2["Half3Dots"] = "2...";
+  NoteLength2["Half4Dots"] = "2....";
+  NoteLength2["Half5Dots"] = "2.....";
+  NoteLength2["Quarter"] = "4n";
+  NoteLength2["QuarterTriplet"] = "4t";
+  NoteLength2["QuarterDot"] = "4.";
+  NoteLength2["Quarter2Dots"] = "4..";
+  NoteLength2["Quarter3Dots"] = "4...";
+  NoteLength2["Quarter4Dots"] = "4....";
+  NoteLength2["Eighth"] = "8n";
+  NoteLength2["EighthTriplet"] = "8t";
+  NoteLength2["EighthDot"] = "8.";
+  NoteLength2["Eighth2Dots"] = "8..";
+  NoteLength2["Eighth3Dots"] = "8...";
+  NoteLength2["Sixteenth"] = "16n";
+  NoteLength2["SixteenthTriplet"] = "16t";
+  NoteLength2["SixteenthDot"] = "16.";
+  NoteLength2["Sixteenth2Dots"] = "16..";
+  NoteLength2["ThirtySecond"] = "32n";
+  NoteLength2["ThirtySecondTriplet"] = "32t";
+  NoteLength2["ThirtySecondDot"] = "32.";
+  NoteLength2["SixtyFourth"] = "64n";
+  NoteLength2["SixtyFourthTriplet"] = "64t";
+  return NoteLength2;
+})(NoteLength || {});
+function isNoteLength(noteLength) {
+  return guard_exports.isEnumValue(noteLength, NoteLength);
+}
+function validateNoteLength(noteLength) {
+  if (isNoteLength(noteLength)) {
+    return noteLength;
+  } else {
+    throw new MusicError(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 = utils_exports.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 MusicError(MusicErrorType.Note, `dotCount ${this.dotCount} > maxDotCount ${this.maxDotCount}, for noteLength "${this.noteLength}".`);
+    } else if (this.isTriplet && this.dotCount > 0) {
+      throw new MusicError(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) {
+    return this.cache.getOrCreate(noteLength, () => new _NoteLengthProps(noteLength));
+  }
+  /**
+   * 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 + (guard_exports.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 utils_exports.Math.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(...utils_exports.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+/** Shortest note size (e.g. 64 = sixtyfourth note). */
+__publicField(_NoteLengthProps, "ShortestNoteSize", Math.max(...utils_exports.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+__publicField(_NoteLengthProps, "cache", new UniMap());
+var NoteLengthProps = _NoteLengthProps;
+function isTupletRatio(tupletRatio) {
+  return guard_exports.isObject(tupletRatio) && guard_exports.isIntegerBetween(tupletRatio.parts, 2, MaxTupletRatioValue) && guard_exports.isIntegerBetween(tupletRatio.inTimeOf, 2, MaxTupletRatioValue);
+}
+function validateTupletRatio(tupletRatio) {
+  if (isTupletRatio(tupletRatio)) {
+    return tupletRatio;
+  } else {
+    throw new MusicError(MusicErrorType.Note, `Invalid tupletRatio ${JSON.stringify(tupletRatio)}`);
+  }
+}
+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");
+    /** 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");
+    /** Has note stem. */
+    __publicField(this, "hasStem");
+    /** Is note head solid (black)? */
+    __publicField(this, "isSolidNoteHead");
+    this.noteLength = validateNoteLength(noteLength);
+    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 (guard_exports.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 MusicError(MusicErrorType.Note, `Note cannot be both dotted and tuplet!`);
+    } else if (this.dotCount > p.maxDotCount) {
+      throw new MusicError(MusicErrorType.Note, `Too big dot count ${this.dotCount} for note length ${this.noteLength}.`);
+    }
+    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;
+    }
+  }
+  /**
+   * 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");
+  }
+  /**
+   * 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 {
+      return this.cache.getOrCreate(noteLength, () => new _RhythmProps(noteLength));
+    }
+  }
+  /**
+   * 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 utils_exports.Math.cmp(a.ticks, b.ticks);
+  }
+  /**
+   * 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", new 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 UniMap());
+var RhythmProps = _RhythmProps;
+
+export {
+  NoteLength,
+  isNoteLength,
+  validateNoteLength,
+  NoteLengthProps,
+  isTupletRatio,
+  validateTupletRatio,
+  Tuplet,
+  RhythmProps
+};
+//# sourceMappingURL=chunk-GNT3ECDB.mjs.map