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

package/dist/audio-synth/index.mjs

@@ -0,0 +1,63 @@
+/* WebMusicScore v6.0.0-pre.0 | (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-OKY6DMTT.mjs";
+import {
+  linearToDecibels
+} from "../chunk-SNZ77AGL.mjs";
+import {
+  __publicField
+} from "../chunk-2NTPGV6U.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-2NTPGV6U.mjs

@@ -0,0 +1,101 @@
+/* WebMusicScore v6.0.0-pre.0 | (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-2NTPGV6U.mjs.map

package/dist/chunk-FCR7WBDV.mjs

@@ -0,0 +1,37 @@
+/* WebMusicScore v6.0.0-pre.0 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+import {
+  __publicField
+} from "./chunk-2NTPGV6U.mjs";
+
+// src/core/error.ts
+var MusicErrorType = /* @__PURE__ */ ((MusicErrorType2) => {
+  MusicErrorType2[MusicErrorType2["Unknown"] = 0] = "Unknown";
+  MusicErrorType2[MusicErrorType2["InvalidArg"] = 1] = "InvalidArg";
+  MusicErrorType2[MusicErrorType2["Note"] = 2] = "Note";
+  MusicErrorType2[MusicErrorType2["Scale"] = 3] = "Scale";
+  MusicErrorType2[MusicErrorType2["KeySignature"] = 4] = "KeySignature";
+  MusicErrorType2[MusicErrorType2["Timesignature"] = 5] = "Timesignature";
+  MusicErrorType2[MusicErrorType2["Score"] = 6] = "Score";
+  MusicErrorType2[MusicErrorType2["Audio"] = 7] = "Audio";
+  return MusicErrorType2;
+})(MusicErrorType || {});
+function formatType(type) {
+  return type === void 0 ? "" : `[${MusicErrorType[type]}] `;
+}
+var MusicError = class extends Error {
+  constructor(...args) {
+    const [type, msg] = args.length === 1 ? [0 /* Unknown */, args[0]] : args;
+    super(formatType(type) + msg);
+    /** Music error type. */
+    __publicField(this, "type");
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "MusicError";
+    this.type = type;
+  }
+};
+
+export {
+  MusicErrorType,
+  MusicError
+};
+//# sourceMappingURL=chunk-FCR7WBDV.mjs.map