midiwire 0.11.2 → 0.12.0

package/dist/midiwire.es.js

@@ -1,4 +1,7 @@
-class w {
+var x = Object.defineProperty;
+var Y = (c, e, i) => e in c ? x(c, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : c[e] = i;
+var _ = (c, e, i) => Y(c, typeof e != "symbol" ? e + "" : e, i);
+class $ {
   /**
    * Create a new DataAttributeBinder instance for declarative MIDI binding
    *
@@ -22,8 +25,8 @@ class w {
    *   binder.bindAll();
    * });
    */
-  constructor(t, s = "[data-midi-cc]") {
-    this.controller = t, this.selector = s, this.observer = null;
+  constructor(e, i = "[data-midi-cc]") {
+    this.controller = e, this.selector = i, this.observer = null;
   }
   /**
    * Bind all matching elements in the document to MIDI Controller. Searches the DOM for elements
@@ -51,10 +54,10 @@ class w {
   bindAll() {
     document.querySelectorAll(
       this.selector === "[data-midi-cc]" ? "[data-midi-cc], [data-midi-msb][data-midi-lsb]" : this.selector
-    ).forEach((s) => {
-      if (s.hasAttribute("data-midi-bound")) return;
-      const E = this._parseAttributes(s);
-      E && (this.controller.bind(s, E), s.setAttribute("data-midi-bound", "true"));
+    ).forEach((i) => {
+      if (i.hasAttribute("data-midi-bound")) return;
+      const n = this._parseAttributes(i);
+      n && (this.controller.bind(i, n), i.setAttribute("data-midi-bound", "true"));
     });
   }
   /**
@@ -80,25 +83,25 @@ class w {
    */
   enableAutoBinding() {
     if (this.observer) return;
-    const t = this.selector === "[data-midi-cc]" ? "[data-midi-cc], [data-midi-msb][data-midi-lsb]" : this.selector;
-    this.observer = new MutationObserver((s) => {
-      s.forEach((E) => {
-        E.addedNodes.forEach((e) => {
-          if (e.nodeType === Node.ELEMENT_NODE) {
-            if (e.matches?.(t)) {
-              const _ = this._parseAttributes(e);
-              _ && !e.hasAttribute("data-midi-bound") && (this.controller.bind(e, _), e.setAttribute("data-midi-bound", "true"));
+    const e = this.selector === "[data-midi-cc]" ? "[data-midi-cc], [data-midi-msb][data-midi-lsb]" : this.selector;
+    this.observer = new MutationObserver((i) => {
+      i.forEach((n) => {
+        n.addedNodes.forEach((s) => {
+          if (s.nodeType === Node.ELEMENT_NODE) {
+            if (s.matches?.(e)) {
+              const r = this._parseAttributes(s);
+              r && !s.hasAttribute("data-midi-bound") && (this.controller.bind(s, r), s.setAttribute("data-midi-bound", "true"));
             }
-            e.querySelectorAll && e.querySelectorAll(t).forEach((i) => {
-              if (!i.hasAttribute("data-midi-bound")) {
-                const r = this._parseAttributes(i);
-                r && (this.controller.bind(i, r), i.setAttribute("data-midi-bound", "true"));
+            s.querySelectorAll && s.querySelectorAll(e).forEach((E) => {
+              if (!E.hasAttribute("data-midi-bound")) {
+                const o = this._parseAttributes(E);
+                o && (this.controller.bind(E, o), E.setAttribute("data-midi-bound", "true"));
               }
             });
           }
-        }), E.removedNodes.forEach((e) => {
-          e.nodeType === Node.ELEMENT_NODE && (e.hasAttribute?.("data-midi-bound") && this.controller.unbind(e), e.querySelectorAll && e.querySelectorAll("[data-midi-bound]").forEach((i) => {
-            this.controller.unbind(i);
+        }), n.removedNodes.forEach((s) => {
+          s.nodeType === Node.ELEMENT_NODE && (s.hasAttribute?.("data-midi-bound") && this.controller.unbind(s), s.querySelectorAll && s.querySelectorAll("[data-midi-bound]").forEach((E) => {
+            this.controller.unbind(E);
           }));
         });
       });
@@ -149,33 +152,33 @@ class w {
    * // <input type="range" min="0" max="16383" data-midi-msb="74" data-midi-lsb="75">
    * // Returns: { msb: 74, lsb: 75, is14Bit: true, min: 0, max: 16383 }
    */
-  _parseAttributes(t) {
-    const s = parseInt(t.dataset.midiMsb, 10), E = parseInt(t.dataset.midiLsb, 10);
-    if (!Number.isNaN(s) && !Number.isNaN(E) && s >= 0 && s <= 127 && E >= 0 && E <= 127) {
-      const _ = parseInt(t.dataset.midiCc, 10);
-      return !Number.isNaN(_) && _ >= 0 && _ <= 127 && console.warn(
-        `Element has both 7-bit (data-midi-cc="${_}") and 14-bit (data-midi-msb="${s}" data-midi-lsb="${E}") CC attributes. 14-bit takes precedence.`,
-        t
+  _parseAttributes(e) {
+    const i = parseInt(e.dataset.midiMsb, 10), n = parseInt(e.dataset.midiLsb, 10);
+    if (!Number.isNaN(i) && !Number.isNaN(n) && i >= 0 && i <= 127 && n >= 0 && n <= 127) {
+      const r = parseInt(e.dataset.midiCc, 10);
+      return !Number.isNaN(r) && r >= 0 && r <= 127 && console.warn(
+        `Element has both 7-bit (data-midi-cc="${r}") and 14-bit (data-midi-msb="${i}" data-midi-lsb="${n}") CC attributes. 14-bit takes precedence.`,
+        e
       ), {
-        msb: s,
-        lsb: E,
+        msb: i,
+        lsb: n,
         is14Bit: !0,
-        channel: parseInt(t.dataset.midiChannel, 10) || void 0,
-        min: parseFloat(t.getAttribute("min")) || 0,
-        max: parseFloat(t.getAttribute("max")) || 127,
-        invert: t.dataset.midiInvert === "true",
-        label: t.dataset.midiLabel
+        channel: parseInt(e.dataset.midiChannel, 10) || void 0,
+        min: parseFloat(e.getAttribute("min")) || 0,
+        max: parseFloat(e.getAttribute("max")) || 127,
+        invert: e.dataset.midiInvert === "true",
+        label: e.dataset.midiLabel
       };
     }
-    const e = parseInt(t.dataset.midiCc, 10);
-    return !Number.isNaN(e) && e >= 0 && e <= 127 ? {
-      cc: e,
-      channel: parseInt(t.dataset.midiChannel, 10) || void 0,
-      min: parseFloat(t.getAttribute("min")) || 0,
-      max: parseFloat(t.getAttribute("max")) || 127,
-      invert: t.dataset.midiInvert === "true",
-      label: t.dataset.midiLabel
-    } : ((t.dataset.midiCc !== void 0 || t.dataset.midiMsb !== void 0 && t.dataset.midiLsb !== void 0) && console.warn("Invalid MIDI configuration on element:", t), null);
+    const s = parseInt(e.dataset.midiCc, 10);
+    return !Number.isNaN(s) && s >= 0 && s <= 127 ? {
+      cc: s,
+      channel: parseInt(e.dataset.midiChannel, 10) || void 0,
+      min: parseFloat(e.getAttribute("min")) || 0,
+      max: parseFloat(e.getAttribute("max")) || 127,
+      invert: e.dataset.midiInvert === "true",
+      label: e.dataset.midiLabel
+    } : ((e.dataset.midiCc !== void 0 || e.dataset.midiMsb !== void 0 && e.dataset.midiLsb !== void 0) && console.warn("Invalid MIDI configuration on element:", e), null);
   }
   /**
    * Clean up resources and disconnect any active observers. Disables auto-binding if active
@@ -203,59 +206,59 @@ class w {
     this.disableAutoBinding();
   }
 }
-class R extends Error {
-  constructor(t, s) {
-    super(t), this.name = "MIDIError", this.code = s, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+class g extends Error {
+  constructor(e, i) {
+    super(e), this.name = "MIDIError", this.code = i, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
   }
 }
-class g extends R {
-  constructor(t, s) {
-    super(t, "MIDI_ACCESS_ERROR"), this.name = "MIDIAccessError", this.reason = s;
+class F extends g {
+  constructor(e, i) {
+    super(e, "MIDI_ACCESS_ERROR"), this.name = "MIDIAccessError", this.reason = i;
   }
 }
-class F extends R {
-  constructor(t) {
-    super(t, "MIDI_CONNECTION_ERROR"), this.name = "MIDIConnectionError";
+class y extends g {
+  constructor(e) {
+    super(e, "MIDI_CONNECTION_ERROR"), this.name = "MIDIConnectionError";
   }
 }
-class K extends R {
-  constructor(t, s, E) {
-    super(t, "MIDI_DEVICE_ERROR"), this.name = "MIDIDeviceError", this.deviceType = s, this.deviceId = E;
+class U extends g {
+  constructor(e, i, n) {
+    super(e, "MIDI_DEVICE_ERROR"), this.name = "MIDIDeviceError", this.deviceType = i, this.deviceId = n;
   }
 }
-class L extends R {
-  constructor(t, s) {
-    super(t, "MIDI_VALIDATION_ERROR"), this.name = "MIDIValidationError", this.validationType = s;
+class m extends g {
+  constructor(e, i) {
+    super(e, "MIDI_VALIDATION_ERROR"), this.name = "MIDIValidationError", this.validationType = i;
   }
 }
-class b extends Error {
-  constructor(t, s) {
-    super(t), this.name = "DX7Error", this.code = s, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+class v extends Error {
+  constructor(e, i) {
+    super(e), this.name = "DX7Error", this.code = i, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
   }
 }
-class m extends b {
-  constructor(t, s, E) {
-    super(t, "DX7_PARSE_ERROR"), this.name = "DX7ParseError", this.parseType = s, this.offset = E;
+class R extends v {
+  constructor(e, i, n) {
+    super(e, "DX7_PARSE_ERROR"), this.name = "DX7ParseError", this.parseType = i, this.offset = n;
   }
 }
-class c extends b {
-  constructor(t, s, E) {
-    super(t, "DX7_VALIDATION_ERROR"), this.name = "DX7ValidationError", this.validationType = s, this.value = E;
+class O extends v {
+  constructor(e, i, n) {
+    super(e, "DX7_VALIDATION_ERROR"), this.name = "DX7ValidationError", this.validationType = i, this.value = n;
   }
 }
-function O(A, t, s) {
-  return Math.max(t, Math.min(s, A));
+function D(c, e, i) {
+  return Math.max(e, Math.min(i, c));
 }
-function x(A, t, s, E = !1) {
-  const e = (A - t) / (s - t), i = (E ? 1 - e : e) * 127;
-  return O(Math.round(i), 0, 127);
+function Z(c, e, i, n = !1) {
+  const s = (c - e) / (i - e), E = (n ? 1 - s : s) * 127;
+  return D(Math.round(E), 0, 127);
 }
-function Q(A, t, s, E = !1) {
-  let e = O(A, 0, 127) / 127;
-  return E && (e = 1 - e), t + e * (s - t);
+function tt(c, e, i, n = !1) {
+  let s = D(c, 0, 127) / 127;
+  return n && (s = 1 - s), e + s * (i - e);
 }
-function J(A) {
-  const t = {
+function et(c) {
+  const e = {
     C: 0,
     "C#": 1,
     DB: 1,
@@ -273,27 +276,27 @@ function J(A) {
     "A#": 10,
     BB: 10,
     B: 11
-  }, s = A.match(/^([A-G][#b]?)(-?\d+)$/i);
-  if (!s)
-    throw new L(`Invalid note name: ${A}`, "note", A);
-  const [, E, e] = s, _ = t[E.toUpperCase()];
-  if (_ === void 0)
-    throw new L(`Invalid note: ${E}`, "note", E);
-  const i = (parseInt(e, 10) + 1) * 12 + _;
-  return O(i, 0, 127);
+  }, i = c.match(/^([A-G][#b]?)(-?\d+)$/i);
+  if (!i)
+    throw new m(`Invalid note name: ${c}`, "note", c);
+  const [, n, s] = i, r = e[n.toUpperCase()];
+  if (r === void 0)
+    throw new m(`Invalid note: ${n}`, "note", n);
+  const E = (parseInt(s, 10) + 1) * 12 + r;
+  return D(E, 0, 127);
 }
-function j(A, t = !1) {
-  const e = t ? ["C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B"] : ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], _ = Math.floor(A / 12) - 1;
-  return `${e[A % 12]}${_}`;
+function it(c, e = !1) {
+  const s = e ? ["C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B"] : ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], r = Math.floor(c / 12) - 1;
+  return `${s[c % 12]}${r}`;
 }
-function k(A) {
-  const t = 69 + 12 * Math.log2(A / 440);
-  return O(Math.round(t), 0, 127);
+function nt(c) {
+  const e = 69 + 12 * Math.log2(c / 440);
+  return D(Math.round(e), 0, 127);
 }
-function V(A) {
-  return 440 * 2 ** ((A - 69) / 12);
+function st(c) {
+  return 440 * 2 ** ((c - 69) / 12);
 }
-function X(A) {
+function Et(c) {
   return {
     0: "Bank Select",
     1: "Modulation",
@@ -326,27 +329,27 @@ function X(A) {
     120: "All Sound Off",
     121: "Reset All Controllers",
     123: "All Notes Off"
-  }[A] || `CC ${A}`;
+  }[c] || `CC ${c}`;
 }
-function B(A) {
-  const t = O(Math.round(A), 0, 16383);
+function z(c) {
+  const e = D(Math.round(c), 0, 16383);
   return {
-    msb: t >> 7 & 127,
-    lsb: t & 127
+    msb: e >> 7 & 127,
+    lsb: e & 127
   };
 }
-function Y(A, t) {
-  return O(A, 0, 127) << 7 | O(t, 0, 127);
+function q(c, e) {
+  return D(c, 0, 127) << 7 | D(e, 0, 127);
 }
-function $(A, t, s, E = !1) {
-  const e = (A - t) / (s - t), i = (E ? 1 - e : e) * 16383;
-  return B(i);
+function W(c, e, i, n = !1) {
+  const s = (c - e) / (i - e), E = (n ? 1 - s : s) * 16383;
+  return z(E);
 }
-function tt(A, t, s, E, e = !1) {
-  let i = Y(A, t) / 16383;
-  return e && (i = 1 - i), s + i * (E - s);
+function rt(c, e, i, n, s = !1) {
+  let E = q(c, e) / 16383;
+  return s && (E = 1 - E), i + E * (n - i);
 }
-class H {
+class w {
   constructor() {
     this.events = /* @__PURE__ */ new Map();
   }
@@ -356,42 +359,42 @@ class H {
    * @param {Function} handler - Event handler function
    * @returns {Function} Unsubscribe function
    */
-  on(t, s) {
-    return this.events.has(t) || this.events.set(t, []), this.events.get(t).push(s), () => this.off(t, s);
+  on(e, i) {
+    return this.events.has(e) || this.events.set(e, []), this.events.get(e).push(i), () => this.off(e, i);
   }
   /**
    * Register a one-time event listener
    * @param {string} event - Event name
    * @param {Function} handler - Event handler function
    */
-  once(t, s) {
-    const E = (...e) => {
-      s(...e), this.off(t, E);
+  once(e, i) {
+    const n = (...s) => {
+      i(...s), this.off(e, n);
     };
-    this.on(t, E);
+    this.on(e, n);
   }
   /**
    * Remove an event listener
    * @param {string} event - Event name
    * @param {Function} handler - Event handler function
    */
-  off(t, s) {
-    if (!this.events.has(t)) return;
-    const E = this.events.get(t), e = E.indexOf(s);
-    e > -1 && E.splice(e, 1), E.length === 0 && this.events.delete(t);
+  off(e, i) {
+    if (!this.events.has(e)) return;
+    const n = this.events.get(e), s = n.indexOf(i);
+    s > -1 && n.splice(s, 1), n.length === 0 && this.events.delete(e);
   }
   /**
    * Emit an event
    * @param {string} event - Event name
    * @param {*} data - Event data
    */
-  emit(t, s) {
-    if (!this.events.has(t)) return;
-    [...this.events.get(t)].forEach((e) => {
+  emit(e, i) {
+    if (!this.events.has(e)) return;
+    [...this.events.get(e)].forEach((s) => {
       try {
-        e(s);
-      } catch (_) {
-        console.error(`Error in event handler for "${t}":`, _);
+        s(i);
+      } catch (r) {
+        console.error(`Error in event handler for "${e}":`, r);
       }
     });
   }
@@ -399,26 +402,26 @@ class H {
    * Remove all event listeners
    * @param {string} [event] - Optional event name to clear specific event
    */
-  removeAllListeners(t) {
-    t ? this.events.delete(t) : this.events.clear();
+  removeAllListeners(e) {
+    e ? this.events.delete(e) : this.events.clear();
   }
 }
-const U = {
+const p = {
   DEVICE_CHANGE: "device-change",
   IN_DEV_CONNECTED: "in-dev-connected",
   IN_DEV_DISCONNECTED: "in-dev-disconnected",
   OUT_DEV_CONNECTED: "out-dev-connected",
   OUT_DEV_DISCONNECTED: "out-dev-disconnected"
 };
-class Z extends H {
+class Q extends w {
   /**
    * @param {Object} options
    * @param {boolean} [options.sysex=false] - Request SysEx access
    */
-  constructor(t = {}) {
+  constructor(e = {}) {
     super(), this.options = {
       sysex: !1,
-      ...t
+      ...e
     }, this.midiAccess = null, this.output = null, this.input = null;
   }
   /**
@@ -445,25 +448,25 @@ class Z extends H {
    */
   async requestAccess() {
     if (!navigator.requestMIDIAccess)
-      throw new g("Web MIDI API is not supported in this browser", "unsupported");
+      throw new F("Web MIDI API is not supported in this browser", "unsupported");
     try {
       this.midiAccess = await navigator.requestMIDIAccess({
         sysex: this.options.sysex
-      }), this.midiAccess.onstatechange = (t) => {
-        const s = t.port, E = t.port.state;
-        this.emit(U.DEVICE_CHANGE, {
-          port: s,
-          state: E,
-          type: s.type,
+      }), this.midiAccess.onstatechange = (e) => {
+        const i = e.port, n = e.port.state;
+        this.emit(p.DEVICE_CHANGE, {
+          port: i,
+          state: n,
+          type: i.type,
           device: {
-            id: s.id,
-            name: s.name,
-            manufacturer: s.manufacturer || "Unknown"
+            id: i.id,
+            name: i.name,
+            manufacturer: i.manufacturer || "Unknown"
           }
-        }), E === "disconnected" ? s.type === "input" ? (this.emit(U.IN_DEV_DISCONNECTED, { device: s }), this.input && this.input.id === s.id && (this.input = null)) : s.type === "output" && (this.emit(U.OUT_DEV_DISCONNECTED, { device: s }), this.output && this.output.id === s.id && (this.output = null)) : E === "connected" && (s.type === "input" ? this.emit(U.IN_DEV_CONNECTED, { device: s }) : s.type === "output" && this.emit(U.OUT_DEV_CONNECTED, { device: s }));
+        }), n === "disconnected" ? i.type === "input" ? (this.emit(p.IN_DEV_DISCONNECTED, { device: i }), this.input && this.input.id === i.id && (this.input = null)) : i.type === "output" && (this.emit(p.OUT_DEV_DISCONNECTED, { device: i }), this.output && this.output.id === i.id && (this.output = null)) : n === "connected" && (i.type === "input" ? this.emit(p.IN_DEV_CONNECTED, { device: i }) : i.type === "output" && this.emit(p.OUT_DEV_CONNECTED, { device: i }));
       };
-    } catch (t) {
-      throw t.name === "SecurityError" ? new g("MIDI access denied. SysEx requires user permission.", "denied") : new g(`Failed to get MIDI access: ${t.message}`, "failed");
+    } catch (e) {
+      throw e.name === "SecurityError" ? new F("MIDI access denied. SysEx requires user permission.", "denied") : new F(`Failed to get MIDI access: ${e.message}`, "failed");
     }
   }
   /**
@@ -490,25 +493,25 @@ class Z extends H {
    * // Connect by device ID
    * await connection.connect("input-12345");
    */
-  async connect(t) {
+  async connect(e) {
     if (!this.midiAccess)
-      throw new F("MIDI access not initialized. Call requestAccess() first.");
-    const s = Array.from(this.midiAccess.outputs.values());
-    if (s.length === 0)
-      throw new K("No MIDI output devices available", "output");
-    if (t === void 0) {
-      this.output = s[0];
+      throw new y("MIDI access not initialized. Call requestAccess() first.");
+    const i = Array.from(this.midiAccess.outputs.values());
+    if (i.length === 0)
+      throw new U("No MIDI output devices available", "output");
+    if (e === void 0) {
+      this.output = i[0];
       return;
     }
-    if (typeof t == "number") {
-      if (t < 0 || t >= s.length)
-        throw new K(`Output index ${t} out of range (0-${s.length - 1})`, "output", t);
-      this.output = s[t];
+    if (typeof e == "number") {
+      if (e < 0 || e >= i.length)
+        throw new U(`Output index ${e} out of range (0-${i.length - 1})`, "output", e);
+      this.output = i[e];
       return;
     }
-    if (this.output = s.find((E) => E.name === t || E.id === t), !this.output) {
-      const E = s.map((e) => e.name).join(", ");
-      throw new K(`MIDI output "${t}" not found. Available: ${E}`, "output", t);
+    if (this.output = i.find((n) => n.name === e || n.id === e), !this.output) {
+      const n = i.map((s) => s.name).join(", ");
+      throw new U(`MIDI output "${e}" not found. Available: ${n}`, "output", e);
     }
   }
   /**
@@ -520,26 +523,26 @@ class Z extends H {
    * @throws {MIDIValidationError} If onMessage is not a function
    * @throws {MIDIDeviceError} If device not found or index out of range
    */
-  async connectInput(t, s) {
+  async connectInput(e, i) {
     if (!this.midiAccess)
-      throw new F("MIDI access not initialized. Call requestAccess() first.");
-    if (typeof s != "function")
-      throw new L("onMessage callback must be a function", "callback");
-    const E = Array.from(this.midiAccess.inputs.values());
-    if (E.length === 0)
-      throw new K("No MIDI input devices available", "input");
-    if (this.input && (this.input.onmidimessage = null), t === void 0)
-      this.input = E[0];
-    else if (typeof t == "number") {
-      if (t < 0 || t >= E.length)
-        throw new K(`Input index ${t} out of range (0-${E.length - 1})`, "input", t);
-      this.input = E[t];
-    } else if (this.input = E.find((e) => e.name === t || e.id === t), !this.input) {
-      const e = E.map((_) => _.name).join(", ");
-      throw new K(`MIDI input "${t}" not found. Available: ${e}`, "input", t);
-    }
-    this.input.onmidimessage = (e) => {
-      s(e);
+      throw new y("MIDI access not initialized. Call requestAccess() first.");
+    if (typeof i != "function")
+      throw new m("onMessage callback must be a function", "callback");
+    const n = Array.from(this.midiAccess.inputs.values());
+    if (n.length === 0)
+      throw new U("No MIDI input devices available", "input");
+    if (this.input && (this.input.onmidimessage = null), e === void 0)
+      this.input = n[0];
+    else if (typeof e == "number") {
+      if (e < 0 || e >= n.length)
+        throw new U(`Input index ${e} out of range (0-${n.length - 1})`, "input", e);
+      this.input = n[e];
+    } else if (this.input = n.find((s) => s.name === e || s.id === e), !this.input) {
+      const s = n.map((r) => r.name).join(", ");
+      throw new U(`MIDI input "${e}" not found. Available: ${s}`, "input", e);
+    }
+    this.input.onmidimessage = (s) => {
+      i(s);
     };
   }
   /**
@@ -595,14 +598,14 @@ class Z extends H {
    */
   getOutputs() {
     if (!this.midiAccess) return [];
-    const t = [];
-    return this.midiAccess.outputs.forEach((s) => {
-      s.state === "connected" && t.push({
-        id: s.id,
-        name: s.name,
-        manufacturer: s.manufacturer || "Unknown"
+    const e = [];
+    return this.midiAccess.outputs.forEach((i) => {
+      i.state === "connected" && e.push({
+        id: i.id,
+        name: i.name,
+        manufacturer: i.manufacturer || "Unknown"
       });
-    }), t;
+    }), e;
   }
   /**
    * Get all available MIDI inputs
@@ -610,14 +613,14 @@ class Z extends H {
    */
   getInputs() {
     if (!this.midiAccess) return [];
-    const t = [];
-    return this.midiAccess.inputs.forEach((s) => {
-      s.state === "connected" && t.push({
-        id: s.id,
-        name: s.name,
-        manufacturer: s.manufacturer || "Unknown"
+    const e = [];
+    return this.midiAccess.inputs.forEach((i) => {
+      i.state === "connected" && e.push({
+        id: i.id,
+        name: i.name,
+        manufacturer: i.manufacturer || "Unknown"
       });
-    }), t;
+    }), e;
   }
   /**
    * Send a MIDI message to the connected output. Automatically converts
@@ -639,16 +642,16 @@ class Z extends H {
    * // Send a control change
    * connection.send([0xB0, 7, 64]); // Volume to 64
    */
-  send(t, s = null) {
+  send(e, i = null) {
     if (!this.output) {
       console.warn("No MIDI output connected. Call connect() first.");
       return;
     }
     try {
-      const E = new Uint8Array(t);
-      s === null ? this.output.send(E) : this.output.send(E, s);
-    } catch (E) {
-      console.error("Failed to send MIDI message:", E);
+      const n = new Uint8Array(e);
+      i === null ? this.output.send(n) : this.output.send(n, i);
+    } catch (n) {
+      console.error("Failed to send MIDI message:", n);
     }
   }
   /**
@@ -666,16 +669,16 @@ class Z extends H {
    * // Send pre-wrapped SysEx message
    * connection.sendSysEx([0xF0, 0x41, 0x10, 0x42, 0xF7], false);
    */
-  sendSysEx(t, s = !1) {
+  sendSysEx(e, i = !1) {
     if (!this.options.sysex) {
       console.warn("SysEx not enabled. Initialize with sysex: true");
       return;
     }
-    let E;
-    s ? E = [240, ...t, 247] : E = t, this.send(E);
+    let n;
+    i ? n = [240, ...e, 247] : n = e, this.send(n);
   }
 }
-const C = {
+const P = {
   // Core controller events
   READY: "ready",
   ERROR: "error",
@@ -728,7 +731,7 @@ const C = {
   PATCH_LOADED: "patch-loaded",
   PATCH_DELETED: "patch-deleted"
 };
-class z extends H {
+class J extends w {
   /**
    * @param {Object} options
    * @param {number} [options.inputChannel=1] - Input MIDI channel (1-16)
@@ -740,13 +743,13 @@ class z extends H {
    * @param {Function} [options.onReady] - Callback when MIDI is ready
    * @param {Function} [options.onError] - Error handler
    */
-  constructor(t = {}) {
+  constructor(e = {}) {
     super(), this.options = {
       inputChannel: 1,
       outputChannel: 1,
       autoConnect: !0,
       sysex: !1,
-      ...t
+      ...e
     }, this.connection = null, this.bindings = /* @__PURE__ */ new Map(), this.state = {
       controlChange: /* @__PURE__ */ new Map(),
       // ${channel}:${cc} -> value
@@ -801,28 +804,28 @@ class z extends H {
       return;
     }
     try {
-      this.connection = new Z({
+      this.connection = new Q({
         sysex: this.options.sysex
-      }), await this.connection.requestAccess(), this.connection.on(U.DEVICE_CHANGE, async ({ state: t, type: s, device: E }) => {
+      }), await this.connection.requestAccess(), this.connection.on(p.DEVICE_CHANGE, async ({ state: e, type: i, device: n }) => {
         try {
-          if (t === "connected")
-            s === "output" ? this.emit(C.DEV_OUT_CONNECTED, E) : s === "input" && this.emit(C.DEV_IN_CONNECTED, E);
-          else if (t === "disconnected") {
-            if (s === "output" && E) {
-              const e = this.connection.getCurrentOutput();
-              e && e.id === E.id ? await this._disconnectOutput() : this.emit(C.DEV_OUT_DISCONNECTED, E);
+          if (e === "connected")
+            i === "output" ? this.emit(P.DEV_OUT_CONNECTED, n) : i === "input" && this.emit(P.DEV_IN_CONNECTED, n);
+          else if (e === "disconnected") {
+            if (i === "output" && n) {
+              const s = this.connection.getCurrentOutput();
+              s && s.id === n.id ? await this._disconnectOutput() : this.emit(P.DEV_OUT_DISCONNECTED, n);
             }
-            if (s === "input" && E) {
-              const e = this.connection.getCurrentInput();
-              e && e.id === E.id ? await this._disconnectInput() : this.emit(C.DEV_IN_DISCONNECTED, E);
+            if (i === "input" && n) {
+              const s = this.connection.getCurrentInput();
+              s && s.id === n.id ? await this._disconnectInput() : this.emit(P.DEV_IN_DISCONNECTED, n);
             }
           }
-        } catch (e) {
-          console.error("Error in device change handler:", e), this.emit(C.ERROR, e);
+        } catch (s) {
+          console.error("Error in device change handler:", s), this.emit(P.ERROR, s);
         }
-      }), this.options.autoConnect && await this.connection.connect(this.options.output), this.options.input !== void 0 && await this._connectInput(this.options.input), this.initialized = !0, this.emit(C.READY, this), this.options.onReady?.(this);
-    } catch (t) {
-      throw this.emit(C.ERROR, t), this.options.onError?.(t), t;
+      }), this.options.autoConnect && await this.connection.connect(this.options.output), this.options.input !== void 0 && await this._connectInput(this.options.input), this.initialized = !0, this.emit(P.READY, this), this.options.onReady?.(this);
+    } catch (e) {
+      throw this.emit(P.ERROR, e), this.options.onError?.(e), e;
     }
   }
   /**
@@ -1108,9 +1111,9 @@ class z extends H {
        * // Send data without wrapper (wrapper added automatically)
        * midi.system.sendEx([0x42, 0x30, 0x00, 0x7F]);
        */
-      sendEx: (function(t, s = !1) {
-        return this._sendSysEx(t, s);
-      }).bind(this),
+      sendEx: function(e, i = !1) {
+        return this._sendSysEx(e, i);
+      }.bind(this),
       /**
        * Send a timing clock message (0xF8)
        * Typically used for synchronizing tempo-dependent devices
@@ -1300,12 +1303,12 @@ class z extends H {
    *   }
    * });
    */
-  bind(t, s, E = {}) {
-    if (!t)
+  bind(e, i, n = {}) {
+    if (!e)
       return console.warn("Cannot bind: element is null or undefined"), () => {
       };
-    const e = this._createBinding(t, s, E);
-    return this.bindings.set(t, e), this.initialized && this.connection?.isConnected() && e.handler({ target: t }), () => this.unbind(t);
+    const s = this._createBinding(e, i, n);
+    return this.bindings.set(e, s), this.initialized && this.connection?.isConnected() && s.handler({ target: e }), () => this.unbind(e);
   }
   /**
    * Create a binding between an element and MIDI CC
@@ -1315,60 +1318,60 @@ class z extends H {
    * @param {Object} options - Additional binding options
    * @returns {Object} Binding object with element, config, handler, and destroy function
    */
-  _createBinding(t, s, E = {}) {
+  _createBinding(e, i, n = {}) {
     const {
-      min: e = parseFloat(t.getAttribute("min")) || 0,
-      max: _ = parseFloat(t.getAttribute("max")) || 127,
-      channel: i,
-      invert: r = !1,
-      onInput: u = void 0
-    } = s, { debounce: S = 0 } = E, P = {
-      ...s,
-      min: e,
-      max: _,
-      invert: r,
-      onInput: u
+      min: s = parseFloat(e.getAttribute("min")) || 0,
+      max: r = parseFloat(e.getAttribute("max")) || 127,
+      channel: E,
+      invert: o = !1,
+      onInput: l = void 0
+    } = i, { debounce: S = 0 } = n, u = {
+      ...i,
+      min: s,
+      max: r,
+      invert: o,
+      onInput: l
     };
-    if (i !== void 0 && (P.channel = i), s.is14Bit) {
-      const { msb: d, lsb: T } = s, f = (M) => {
-        const D = parseFloat(M.target.value);
-        if (Number.isNaN(D)) return;
-        const { msb: y, lsb: v } = $(D, e, _, r), G = i || this.options.outputChannel;
-        this._sendCC(d, y, G), this._sendCC(T, v, G);
+    if (E !== void 0 && (u.channel = E), i.is14Bit) {
+      const { msb: d, lsb: T } = i, f = (G) => {
+        const b = parseFloat(G.target.value);
+        if (Number.isNaN(b)) return;
+        const { msb: V, lsb: B } = W(b, s, r, o), H = E || this.options.outputChannel;
+        this._sendCC(d, V, H), this._sendCC(T, B, H);
       };
       let I = null;
-      const p = S > 0 ? (M) => {
+      const L = S > 0 ? (G) => {
         I && clearTimeout(I), I = setTimeout(() => {
-          f(M), I = null;
+          f(G), I = null;
         }, S);
       } : f;
-      return t.addEventListener("input", p), t.addEventListener("change", p), {
-        element: t,
-        config: P,
+      return e.addEventListener("input", L), e.addEventListener("change", L), {
+        element: e,
+        config: u,
         handler: f,
         destroy: () => {
-          I && clearTimeout(I), t.removeEventListener("input", p), t.removeEventListener("change", p);
+          I && clearTimeout(I), e.removeEventListener("input", L), e.removeEventListener("change", L);
         }
       };
     }
-    const { cc: a } = s, o = (d) => {
+    const { cc: a } = i, A = (d) => {
       const T = parseFloat(d.target.value);
       if (Number.isNaN(T)) return;
-      const f = x(T, e, _, r), I = i === void 0 ? this.options.outputChannel : i;
+      const f = Z(T, s, r, o), I = E === void 0 ? this.options.outputChannel : E;
       this._sendCC(a, f, I);
     };
     let h = null;
     const N = S > 0 ? (d) => {
       h && clearTimeout(h), h = setTimeout(() => {
-        o(d), h = null;
+        A(d), h = null;
       }, S);
-    } : o;
-    return t.addEventListener("input", N), t.addEventListener("change", N), {
-      element: t,
-      config: P,
-      handler: o,
+    } : A;
+    return e.addEventListener("input", N), e.addEventListener("change", N), {
+      element: e,
+      config: u,
+      handler: A,
       destroy: () => {
-        h && clearTimeout(h), t.removeEventListener("input", N), t.removeEventListener("change", N);
+        h && clearTimeout(h), e.removeEventListener("input", N), e.removeEventListener("change", N);
       }
     };
   }
@@ -1376,18 +1379,18 @@ class z extends H {
    * Unbind a control
    * @param {HTMLElement} element
    */
-  unbind(t) {
-    const s = this.bindings.get(t);
-    s && (s.destroy(), this.bindings.delete(t));
+  unbind(e) {
+    const i = this.bindings.get(e);
+    i && (i.destroy(), this.bindings.delete(e));
   }
   /**
    * Clean up resources
    * @returns {Promise<void>}
    */
   async destroy() {
-    for (const t of this.bindings.values())
-      t.destroy();
-    this.bindings.clear(), this.state.controlChange.clear(), this.state.programChange.clear(), this.state.pitchBend.clear(), this.state.monoPressure.clear(), this.state.polyPressure.clear(), await this._disconnect(), this.initialized = !1, this.emit(C.DESTROYED), this.removeAllListeners();
+    for (const e of this.bindings.values())
+      e.destroy();
+    this.bindings.clear(), this.state.controlChange.clear(), this.state.programChange.clear(), this.state.pitchBend.clear(), this.state.monoPressure.clear(), this.state.polyPressure.clear(), await this._disconnect(), this.initialized = !1, this.emit(P.DESTROYED), this.removeAllListeners();
   }
   /**
    * Connect to MIDI output device
@@ -1395,8 +1398,8 @@ class z extends H {
    * @param {string|number|undefined} device - Device identifier (name, ID, index) or undefined for auto-connect
    * @returns {Promise<void>}
    */
-  async _connect(t) {
-    t ? await this.connection.connect(t) : this.options.output !== void 0 ? await this.connection.connect(this.options.output) : this.options.autoConnect && await this.connection.connect();
+  async _connect(e) {
+    e ? await this.connection.connect(e) : this.options.output !== void 0 ? await this.connection.connect(this.options.output) : this.options.autoConnect && await this.connection.connect();
   }
   /**
    * Disconnect from current MIDI output device
@@ -1412,10 +1415,10 @@ class z extends H {
    * @param {string|number} device - Input device identifier (name, ID, index)
    * @returns {Promise<void>}
    */
-  async _connectInput(t) {
-    await this.connection.connectInput(t, (s) => {
-      this._handleMIDIMessage(s);
-    }), this.emit(C.DEV_IN_CONNECTED, this.connection.getCurrentInput());
+  async _connectInput(e) {
+    await this.connection.connectInput(e, (i) => {
+      this._handleMIDIMessage(i);
+    }), this.emit(P.DEV_IN_CONNECTED, this.connection.getCurrentInput());
   }
   /**
    * Disconnect from MIDI input device
@@ -1423,8 +1426,8 @@ class z extends H {
    * @returns {Promise<void>}
    */
   async _disconnectInput() {
-    const t = this.connection.getCurrentInput();
-    this.connection.disconnectInput(), this.emit(C.DEV_IN_DISCONNECTED, t);
+    const e = this.connection.getCurrentInput();
+    this.connection.disconnectInput(), this.emit(P.DEV_IN_DISCONNECTED, e);
   }
   /**
    * Connect to MIDI output device
@@ -1432,8 +1435,8 @@ class z extends H {
    * @param {string|number} output - Output device identifier (name, ID, index)
    * @returns {Promise<void>}
    */
-  async _connectOutput(t) {
-    await this.connection.connect(t), this.emit(C.DEV_OUT_CONNECTED, this.connection.getCurrentOutput());
+  async _connectOutput(e) {
+    await this.connection.connect(e), this.emit(P.DEV_OUT_CONNECTED, this.connection.getCurrentOutput());
   }
   /**
    * Disconnect from MIDI output device
@@ -1441,8 +1444,8 @@ class z extends H {
    * @returns {Promise<void>}
    */
   async _disconnectOutput() {
-    const t = this.connection.getCurrentOutput();
-    this.connection.disconnectOutput(), this.emit(C.DEV_OUT_DISCONNECTED, t);
+    const e = this.connection.getCurrentOutput();
+    this.connection.disconnectOutput(), this.emit(P.DEV_OUT_DISCONNECTED, e);
   }
   /**
    * Get current output device information
@@ -1480,12 +1483,12 @@ class z extends H {
    * Send raw MIDI data
    * @param {Array<number>} data - MIDI message bytes
    */
-  send(t) {
+  send(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    this.connection.send(t);
+    this.connection.send(e);
   }
   /**
    * Send Note On message
@@ -1495,11 +1498,11 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default outputChannel)
    * @returns {void}
    */
-  _sendNoteOn(t, s = 64, E = this.options.outputChannel) {
+  _sendNoteOn(e, i = 64, n = this.options.outputChannel) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 127), s = O(Math.round(s), 0, 127), E = O(Math.round(E), 1, 16);
-    const e = 144 + (E - 1);
-    this.connection.send([e, t, s]), this.emit(C.CH_NOTE_ON_SEND, { note: t, velocity: s, channel: E });
+    e = D(Math.round(e), 0, 127), i = D(Math.round(i), 0, 127), n = D(Math.round(n), 1, 16);
+    const s = 144 + (n - 1);
+    this.connection.send([s, e, i]), this.emit(P.CH_NOTE_ON_SEND, { note: e, velocity: i, channel: n });
   }
   /**
    * Send Note Off message
@@ -1509,11 +1512,11 @@ class z extends H {
    * @param {number} velocity - Release velocity (0-127, default 0)
    * @returns {void}
    */
-  _sendNoteOff(t, s = this.options.outputChannel, E = 0) {
+  _sendNoteOff(e, i = this.options.outputChannel, n = 0) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 127), E = O(Math.round(E), 0, 127), s = O(Math.round(s), 1, 16);
-    const e = 144 + (s - 1);
-    this.connection.send([e, t, E]), this.emit(C.CH_NOTE_OFF_SEND, { note: t, channel: s, velocity: E });
+    e = D(Math.round(e), 0, 127), n = D(Math.round(n), 0, 127), i = D(Math.round(i), 1, 16);
+    const s = 144 + (i - 1);
+    this.connection.send([s, e, n]), this.emit(P.CH_NOTE_OFF_SEND, { note: e, channel: i, velocity: n });
   }
   /**
    * Send Control Change message
@@ -1523,16 +1526,16 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default outputChannel)
    * @returns {void}
    */
-  _sendCC(t, s, E = this.options.outputChannel) {
+  _sendCC(e, i, n = this.options.outputChannel) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    t = O(Math.round(t), 0, 127), s = O(Math.round(s), 0, 127), E = O(Math.round(E), 1, 16);
-    const e = 176 + (E - 1);
-    this.connection.send([e, t, s]);
-    const _ = `${E}:${t}`;
-    this.state.controlChange.set(_, s), this.emit(C.CH_CC_SEND, { cc: t, value: s, channel: E });
+    e = D(Math.round(e), 0, 127), i = D(Math.round(i), 0, 127), n = D(Math.round(n), 1, 16);
+    const s = 176 + (n - 1);
+    this.connection.send([s, e, i]);
+    const r = `${n}:${e}`;
+    this.state.controlChange.set(r, i), this.emit(P.CH_CC_SEND, { cc: e, value: i, channel: n });
   }
   /**
    * Send Program Change message
@@ -1541,11 +1544,11 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default outputChannel)
    * @returns {void}
    */
-  _sendPC(t, s = this.options.outputChannel) {
+  _sendPC(e, i = this.options.outputChannel) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 127), s = O(Math.round(s), 1, 16);
-    const E = 192 + (s - 1);
-    this.connection.send([E, t]), this.state.programChange.set(s.toString(), t), this.emit(C.CH_PC_SEND, { program: t, channel: s });
+    e = D(Math.round(e), 0, 127), i = D(Math.round(i), 1, 16);
+    const n = 192 + (i - 1);
+    this.connection.send([n, e]), this.state.programChange.set(i.toString(), e), this.emit(P.CH_PC_SEND, { program: e, channel: i });
   }
   /**
    * Get current Program Change value for channel
@@ -1553,8 +1556,8 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default inputChannel)
    * @returns {number|undefined} Program number or undefined if not set
    */
-  _getPC(t = this.options.inputChannel) {
-    return this.state.programChange.get(t.toString());
+  _getPC(e = this.options.inputChannel) {
+    return this.state.programChange.get(e.toString());
   }
   /**
    * Get current Control Change value
@@ -1563,9 +1566,9 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default inputChannel)
    * @returns {number|undefined} CC value or undefined if not set
    */
-  _getCC(t, s = this.options.inputChannel) {
-    const E = `${s}:${t}`;
-    return this.state.controlChange.get(E);
+  _getCC(e, i = this.options.inputChannel) {
+    const n = `${i}:${e}`;
+    return this.state.controlChange.get(n);
   }
   /**
    * Send Pitch Bend message on specified channel
@@ -1574,11 +1577,11 @@ class z extends H {
    * @param {number} [channel=this.options.outputChannel] - MIDI channel (1-16)
    * @returns {void}
    */
-  _sendPitchBend(t, s = this.options.outputChannel) {
+  _sendPitchBend(e, i = this.options.outputChannel) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 16383), s = O(Math.round(s), 1, 16);
-    const E = 224 + (s - 1), e = t & 127, _ = t >> 7 & 127;
-    this.connection.send([E, e, _]), this.state.pitchBend.set(s.toString(), t), this.emit(C.CH_PITCH_BEND_SEND, { value: t, channel: s });
+    e = D(Math.round(e), 0, 16383), i = D(Math.round(i), 1, 16);
+    const n = 224 + (i - 1), s = e & 127, r = e >> 7 & 127;
+    this.connection.send([n, s, r]), this.state.pitchBend.set(i.toString(), e), this.emit(P.CH_PITCH_BEND_SEND, { value: e, channel: i });
   }
   /**
    * Get current Pitch Bend value for a channel
@@ -1586,8 +1589,8 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default inputChannel)
    * @returns {number|undefined} Pitch bend value (0-16383) or undefined if not set
    */
-  _getPitchBend(t = this.options.inputChannel) {
-    return this.state.pitchBend.get(t.toString());
+  _getPitchBend(e = this.options.inputChannel) {
+    return this.state.pitchBend.get(e.toString());
   }
   /**
    * Send Channel Pressure (Aftertouch) message
@@ -1596,11 +1599,11 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default outputChannel)
    * @returns {void}
    */
-  _sendMonoPressure(t, s = this.options.outputChannel) {
+  _sendMonoPressure(e, i = this.options.outputChannel) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 127), s = O(Math.round(s), 1, 16);
-    const E = 208 + (s - 1);
-    this.connection.send([E, t]), this.state.monoPressure.set(s.toString(), t), this.emit(C.CH_MONO_PRESS_SEND, { pressure: t, channel: s });
+    e = D(Math.round(e), 0, 127), i = D(Math.round(i), 1, 16);
+    const n = 208 + (i - 1);
+    this.connection.send([n, e]), this.state.monoPressure.set(i.toString(), e), this.emit(P.CH_MONO_PRESS_SEND, { pressure: e, channel: i });
   }
   /**
    * Get current Channel Pressure (Aftertouch) value for a channel
@@ -1608,8 +1611,8 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default inputChannel)
    * @returns {number|undefined} Pressure value (0-127) or undefined if not set
    */
-  _getMonoPressure(t = this.options.inputChannel) {
-    return this.state.monoPressure.get(t.toString());
+  _getMonoPressure(e = this.options.inputChannel) {
+    return this.state.monoPressure.get(e.toString());
   }
   /**
    * Send Polyphonic Key Pressure (Polyphonic Aftertouch) message
@@ -1619,13 +1622,13 @@ class z extends H {
    * @param {number} channel - MIDI channel (1-16, default outputChannel)
    * @returns {void}
    */
-  _sendPolyPressure(t, s, E = this.options.outputChannel) {
+  _sendPolyPressure(e, i, n = this.options.outputChannel) {
     if (!this.initialized) return;
-    t = O(Math.round(t), 0, 127), s = O(Math.round(s), 0, 127), E = O(Math.round(E), 1, 16);
-    const e = 160 + (E - 1);
-    this.connection.send([e, t, s]);
-    const _ = `${E}:${t}`;
-    this.state.polyPressure.set(_, s), this.emit(C.CH_POLY_PRESS_SEND, { note: t, pressure: s, channel: E });
+    e = D(Math.round(e), 0, 127), i = D(Math.round(i), 0, 127), n = D(Math.round(n), 1, 16);
+    const s = 160 + (n - 1);
+    this.connection.send([s, e, i]);
+    const r = `${n}:${e}`;
+    this.state.polyPressure.set(r, i), this.emit(P.CH_POLY_PRESS_SEND, { note: e, pressure: i, channel: n });
   }
   /**
    * Get current Polyphonic Pressure (Aftertouch) value for a specific note on a channel
@@ -1634,169 +1637,169 @@ class z extends H {
    * @param {number} [channel=this.options.inputChannel] - MIDI channel (1-16)
    * @returns {number|undefined} Pressure value (0-127) or undefined if not set
    */
-  _getPolyPressure(t, s = this.options.inputChannel) {
-    const E = `${s}:${t}`;
-    return this.state.polyPressure.get(E);
+  _getPolyPressure(e, i = this.options.inputChannel) {
+    const n = `${i}:${e}`;
+    return this.state.polyPressure.get(n);
   }
   /**
    * @private
    */
-  _allSoundsOff(t) {
+  _allSoundsOff(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 120, 0]), this.emit(C.CH_ALL_SOUNDS_OFF_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 120, 0]), this.emit(P.CH_ALL_SOUNDS_OFF_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 120, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 120, 0]);
       }
-      this.emit(C.CH_ALL_SOUNDS_OFF_SEND, { channel: null });
+      this.emit(P.CH_ALL_SOUNDS_OFF_SEND, { channel: null });
     }
   }
   /**
    * @private
    */
-  _resetControllers(t) {
+  _resetControllers(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 121, 0]), this.emit(C.CH_RESET_CONTROLLERS_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 121, 0]), this.emit(P.CH_RESET_CONTROLLERS_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 121, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 121, 0]);
       }
-      this.emit(C.CH_RESET_CONTROLLERS_SEND, { channel: null });
+      this.emit(P.CH_RESET_CONTROLLERS_SEND, { channel: null });
     }
   }
   /**
    * @private
    */
-  _localControl(t, s) {
+  _localControl(e, i) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    const E = t ? 127 : 0;
-    if (s !== void 0) {
-      s = O(Math.round(s), 1, 16);
-      const e = 176 + (s - 1);
-      this.connection.send([e, 122, E]), this.emit(C.CH_LOCAL_CONTROL_SEND, { enabled: t, channel: s });
+    const n = e ? 127 : 0;
+    if (i !== void 0) {
+      i = D(Math.round(i), 1, 16);
+      const s = 176 + (i - 1);
+      this.connection.send([s, 122, n]), this.emit(P.CH_LOCAL_CONTROL_SEND, { enabled: e, channel: i });
     } else {
-      for (let e = 1; e <= 16; e++) {
-        const _ = 176 + (e - 1);
-        this.connection.send([_, 122, E]);
+      for (let s = 1; s <= 16; s++) {
+        const r = 176 + (s - 1);
+        this.connection.send([r, 122, n]);
       }
-      this.emit(C.CH_LOCAL_CONTROL_SEND, { enabled: t, channel: null });
+      this.emit(P.CH_LOCAL_CONTROL_SEND, { enabled: e, channel: null });
     }
   }
   /**
    * @private
    */
-  _allNotesOff(t) {
+  _allNotesOff(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 123, 0]), this.emit(C.CH_ALL_NOTES_OFF_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 123, 0]), this.emit(P.CH_ALL_NOTES_OFF_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 123, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 123, 0]);
       }
-      this.emit(C.CH_ALL_NOTES_OFF_SEND, { channel: null });
+      this.emit(P.CH_ALL_NOTES_OFF_SEND, { channel: null });
     }
   }
   /**
    * @private
    */
-  _omniOff(t) {
+  _omniOff(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 124, 0]), this.emit(C.CH_OMNI_OFF_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 124, 0]), this.emit(P.CH_OMNI_OFF_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 124, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 124, 0]);
       }
-      this.emit(C.CH_OMNI_OFF_SEND, { channel: null });
+      this.emit(P.CH_OMNI_OFF_SEND, { channel: null });
     }
   }
   /**
    * @private
    */
-  _omniOn(t) {
+  _omniOn(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 125, 0]), this.emit(C.CH_OMNI_ON_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 125, 0]), this.emit(P.CH_OMNI_ON_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 125, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 125, 0]);
       }
-      this.emit(C.CH_OMNI_ON_SEND, { channel: null });
+      this.emit(P.CH_OMNI_ON_SEND, { channel: null });
     }
   }
   /**
    * @private
    */
-  _monoOn(t = 1, s) {
+  _monoOn(e = 1, i) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t = Math.max(0, Math.min(16, Math.round(t))), s !== void 0) {
-      s = O(Math.round(s), 1, 16);
-      const E = 176 + (s - 1);
-      this.connection.send([E, 126, t]), this.emit(C.CH_MONO_ON_SEND, { channels: t, channel: s });
+    if (e = Math.max(0, Math.min(16, Math.round(e))), i !== void 0) {
+      i = D(Math.round(i), 1, 16);
+      const n = 176 + (i - 1);
+      this.connection.send([n, 126, e]), this.emit(P.CH_MONO_ON_SEND, { channels: e, channel: i });
     } else {
-      for (let E = 1; E <= 16; E++) {
-        const e = 176 + (E - 1);
-        this.connection.send([e, 126, t]);
+      for (let n = 1; n <= 16; n++) {
+        const s = 176 + (n - 1);
+        this.connection.send([s, 126, e]);
       }
-      this.emit(C.CH_MONO_ON_SEND, { channels: t, channel: null });
+      this.emit(P.CH_MONO_ON_SEND, { channels: e, channel: null });
     }
   }
   /**
    * @private
    */
-  _polyOn(t) {
+  _polyOn(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    if (t !== void 0) {
-      t = O(Math.round(t), 1, 16);
-      const s = 176 + (t - 1);
-      this.connection.send([s, 127, 0]), this.emit(C.CH_POLY_ON_SEND, { channel: t });
+    if (e !== void 0) {
+      e = D(Math.round(e), 1, 16);
+      const i = 176 + (e - 1);
+      this.connection.send([i, 127, 0]), this.emit(P.CH_POLY_ON_SEND, { channel: e });
     } else {
-      for (let s = 1; s <= 16; s++) {
-        const E = 176 + (s - 1);
-        this.connection.send([E, 127, 0]);
+      for (let i = 1; i <= 16; i++) {
+        const n = 176 + (i - 1);
+        this.connection.send([n, 127, 0]);
       }
-      this.emit(C.CH_POLY_ON_SEND, { channel: null });
+      this.emit(P.CH_POLY_ON_SEND, { channel: null });
     }
   }
   /**
@@ -1809,7 +1812,7 @@ class z extends H {
    * this._sendSysEx([0x42, 0x30, 0x00, 0x7F]) // Send without wrapper
    * this._sendSysEx([0xF0, 0x42, 0x30, 0xF7], true) // Send with wrapper
    */
-  _sendSysEx(t, s = !1) {
+  _sendSysEx(e, i = !1) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
@@ -1818,7 +1821,7 @@ class z extends H {
       console.warn("SysEx not enabled. Initialize with sysex: true");
       return;
     }
-    this.connection.sendSysEx(t, s), this.emit(C.SYS_EX_SEND, { data: t, includeWrapper: s });
+    this.connection.sendSysEx(e, i), this.emit(P.SYS_EX_SEND, { data: e, includeWrapper: i });
   }
   /**
    * Send MIDI Timing Clock message (System Real-Time)
@@ -1874,12 +1877,12 @@ class z extends H {
    * @param {number} data - MTC quarter frame data (0-127)
    * @returns {void}
    */
-  _sendMTC(t) {
+  _sendMTC(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    t = O(Math.round(t), 0, 127), this.connection.send([241, t]);
+    e = D(Math.round(e), 0, 127), this.connection.send([241, e]);
   }
   /**
    * Send Song Position Pointer message (System Common)
@@ -1887,14 +1890,14 @@ class z extends H {
    * @param {number} position - Song position in beats (0-16383)
    * @returns {void}
    */
-  _sendSongPosition(t) {
+  _sendSongPosition(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    t = O(Math.round(t), 0, 16383);
-    const s = t & 127, E = t >> 7 & 127;
-    this.connection.send([242, s, E]);
+    e = D(Math.round(e), 0, 16383);
+    const i = e & 127, n = e >> 7 & 127;
+    this.connection.send([242, i, n]);
   }
   /**
    * Send Song Select message (System Common)
@@ -1902,12 +1905,12 @@ class z extends H {
    * @param {number} song - Song/sequence number (0-127)
    * @returns {void}
    */
-  _sendSongSelect(t) {
+  _sendSongSelect(e) {
     if (!this.initialized) {
       console.warn("MIDI not initialized. Call init() first.");
       return;
     }
-    t = O(Math.round(t), 0, 127), this.connection.send([243, t]);
+    e = D(Math.round(e), 0, 127), this.connection.send([243, e]);
   }
   /**
    * Send Tune Request message (System Common)
@@ -1953,148 +1956,148 @@ class z extends H {
    * @param {number} event.midiwire - Timestamp
    * @returns {void}
    */
-  _handleMIDIMessage(t) {
-    const [s, E, e] = t.data, _ = s & 240, i = (s & 15) + 1;
-    if (s === 248) {
-      this.emit(C.SYS_CLOCK_RECV, {
-        timestamp: t.midiwire
+  _handleMIDIMessage(e) {
+    const [i, n, s] = e.data, r = i & 240, E = (i & 15) + 1;
+    if (i === 248) {
+      this.emit(P.SYS_CLOCK_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 250) {
-      this.emit(C.SYS_START_RECV, {
-        timestamp: t.midiwire
+    if (i === 250) {
+      this.emit(P.SYS_START_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 251) {
-      this.emit(C.SYS_CONTINUE_RECV, {
-        timestamp: t.midiwire
+    if (i === 251) {
+      this.emit(P.SYS_CONTINUE_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 252) {
-      this.emit(C.SYS_STOP_RECV, {
-        timestamp: t.midiwire
+    if (i === 252) {
+      this.emit(P.SYS_STOP_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 254) {
-      this.emit(C.SYS_ACT_SENSE_RECV, {
-        timestamp: t.midiwire
+    if (i === 254) {
+      this.emit(P.SYS_ACT_SENSE_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 255) {
-      this.emit(C.SYS_RESET_RECV, {
-        timestamp: t.midiwire
+    if (i === 255) {
+      this.emit(P.SYS_RESET_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 240) {
-      this.emit(C.SYS_EX_RECV, {
-        data: Array.from(t.data),
-        timestamp: t.midiwire
+    if (i === 240) {
+      this.emit(P.SYS_EX_RECV, {
+        data: Array.from(e.data),
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 241) {
-      this.emit(C.SYS_MTC_RECV, {
-        data: E,
-        timestamp: t.midiwire
+    if (i === 241) {
+      this.emit(P.SYS_MTC_RECV, {
+        data: n,
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 242) {
-      const r = E + (e << 7);
-      this.emit(C.SYS_SONG_POS_RECV, {
-        position: r,
-        timestamp: t.midiwire
+    if (i === 242) {
+      const o = n + (s << 7);
+      this.emit(P.SYS_SONG_POS_RECV, {
+        position: o,
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 243) {
-      this.emit(C.SYS_SONG_SEL_RECV, {
-        song: E,
-        timestamp: t.midiwire
+    if (i === 243) {
+      this.emit(P.SYS_SONG_SEL_RECV, {
+        song: n,
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 246) {
-      this.emit(C.SYS_TUNE_REQ_RECV, {
-        timestamp: t.midiwire
+    if (i === 246) {
+      this.emit(P.SYS_TUNE_REQ_RECV, {
+        timestamp: e.midiwire
       });
       return;
     }
-    if (s === 247) {
-      this.emit(C.MIDI_RAW, {
-        status: s,
-        data: [E, e],
-        channel: i,
-        timestamp: t.midiwire
+    if (i === 247) {
+      this.emit(P.MIDI_RAW, {
+        status: i,
+        data: [n, s],
+        channel: E,
+        timestamp: e.midiwire
       });
       return;
     }
-    if (_ === 176) {
-      const r = `${i}:${E}`;
-      this.state.controlChange.set(r, e), this.emit(C.CH_CC_RECV, {
-        cc: E,
-        value: e,
-        channel: i
+    if (r === 176) {
+      const o = `${E}:${n}`;
+      this.state.controlChange.set(o, s), this.emit(P.CH_CC_RECV, {
+        cc: n,
+        value: s,
+        channel: E
       });
       return;
     }
-    if (_ === 192) {
-      this.state.programChange.set(i.toString(), E), this.emit(C.CH_PC_RECV, {
-        program: E,
-        channel: i
+    if (r === 192) {
+      this.state.programChange.set(E.toString(), n), this.emit(P.CH_PC_RECV, {
+        program: n,
+        channel: E
       });
       return;
     }
-    if (_ === 224) {
-      const r = E + (e << 7);
-      this.state.pitchBend.set(i.toString(), r), this.emit(C.CH_PITCH_BEND_RECV, {
-        value: r,
-        channel: i
+    if (r === 224) {
+      const o = n + (s << 7);
+      this.state.pitchBend.set(E.toString(), o), this.emit(P.CH_PITCH_BEND_RECV, {
+        value: o,
+        channel: E
       });
       return;
     }
-    if (_ === 208) {
-      this.state.monoPressure.set(i.toString(), E), this.emit(C.CH_MONO_PRESS_RECV, {
-        pressure: E,
-        channel: i
+    if (r === 208) {
+      this.state.monoPressure.set(E.toString(), n), this.emit(P.CH_MONO_PRESS_RECV, {
+        pressure: n,
+        channel: E
       });
       return;
     }
-    if (_ === 160) {
-      const r = `${i}:${E}`;
-      this.state.polyPressure.set(r, e), this.emit(C.CH_POLY_PRESS_RECV, {
-        note: E,
-        pressure: e,
-        channel: i
+    if (r === 160) {
+      const o = `${E}:${n}`;
+      this.state.polyPressure.set(o, s), this.emit(P.CH_POLY_PRESS_RECV, {
+        note: n,
+        pressure: s,
+        channel: E
       });
       return;
     }
-    if (_ === 144 && e > 0) {
-      this.emit(C.CH_NOTE_ON_RECV, {
-        note: E,
-        velocity: e,
-        channel: i
+    if (r === 144 && s > 0) {
+      this.emit(P.CH_NOTE_ON_RECV, {
+        note: n,
+        velocity: s,
+        channel: E
       });
       return;
     }
-    if (_ === 128 || _ === 144 && e === 0) {
-      this.emit(C.CH_NOTE_OFF_RECV, {
-        note: E,
-        channel: i
+    if (r === 128 || r === 144 && s === 0) {
+      this.emit(P.CH_NOTE_OFF_RECV, {
+        note: n,
+        channel: E
       });
       return;
     }
-    this.emit(C.MIDI_RAW, {
-      status: s,
-      data: [E, e],
-      channel: i,
-      timestamp: t.midiwire
+    this.emit(P.MIDI_RAW, {
+      status: i,
+      data: [n, s],
+      channel: E,
+      timestamp: e.midiwire
     });
   }
   /**
@@ -2103,50 +2106,50 @@ class z extends H {
    * @param {string} [name="Unnamed Patch"] - Patch name
    * @returns {PatchData} Patch data object with channels, settings, and metadata
    */
-  _getPatch(t = "Unnamed Patch") {
-    const s = {
-      name: t,
+  _getPatch(e = "Unnamed Patch") {
+    const i = {
+      name: e,
       device: this._getCurrentOutput()?.name || null,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       version: "1.0",
       channels: {},
       settings: {}
     };
-    for (const [E, e] of this.state.controlChange.entries()) {
-      const [_, i] = E.split(":").map(Number);
-      s.channels[_] || (s.channels[_] = { ccs: {}, notes: {} }), s.channels[_].ccs[i] = e;
-    }
-    for (const [E, e] of this.state.programChange.entries()) {
-      const _ = parseInt(E, 10);
-      s.channels[_] || (s.channels[_] = { ccs: {}, notes: {} }), s.channels[_].program = e;
-    }
-    for (const [E, e] of this.state.pitchBend.entries()) {
-      const _ = parseInt(E, 10);
-      s.channels[_] || (s.channels[_] = { ccs: {}, notes: {} }), s.channels[_].pitchBend = e;
-    }
-    for (const [E, e] of this.state.monoPressure.entries()) {
-      const _ = parseInt(E, 10);
-      s.channels[_] || (s.channels[_] = { ccs: {}, notes: {} }), s.channels[_].monoPressure = e;
-    }
-    for (const [E, e] of this.state.polyPressure.entries()) {
-      const [_, i] = E.split(":").map(Number), r = parseInt(_, 10);
-      s.channels[r] || (s.channels[r] = { ccs: {}, notes: {} }), s.channels[r].polyPressure || (s.channels[r].polyPressure = {}), s.channels[r].polyPressure[i] = e;
-    }
-    for (const [E, e] of this.bindings.entries()) {
-      const { config: _ } = e;
-      if (_.cc) {
-        const i = `cc${_.cc}`;
-        s.settings[i] = {
-          min: _.min,
-          max: _.max,
-          invert: _.invert || !1,
-          is14Bit: _.is14Bit || !1,
-          label: E.getAttribute?.("data-midi-label") || null,
-          elementId: E.id || null
+    for (const [n, s] of this.state.controlChange.entries()) {
+      const [r, E] = n.split(":").map(Number);
+      i.channels[r] || (i.channels[r] = { ccs: {}, notes: {} }), i.channels[r].ccs[E] = s;
+    }
+    for (const [n, s] of this.state.programChange.entries()) {
+      const r = parseInt(n, 10);
+      i.channels[r] || (i.channels[r] = { ccs: {}, notes: {} }), i.channels[r].program = s;
+    }
+    for (const [n, s] of this.state.pitchBend.entries()) {
+      const r = parseInt(n, 10);
+      i.channels[r] || (i.channels[r] = { ccs: {}, notes: {} }), i.channels[r].pitchBend = s;
+    }
+    for (const [n, s] of this.state.monoPressure.entries()) {
+      const r = parseInt(n, 10);
+      i.channels[r] || (i.channels[r] = { ccs: {}, notes: {} }), i.channels[r].monoPressure = s;
+    }
+    for (const [n, s] of this.state.polyPressure.entries()) {
+      const [r, E] = n.split(":").map(Number), o = parseInt(r, 10);
+      i.channels[o] || (i.channels[o] = { ccs: {}, notes: {} }), i.channels[o].polyPressure || (i.channels[o].polyPressure = {}), i.channels[o].polyPressure[E] = s;
+    }
+    for (const [n, s] of this.bindings.entries()) {
+      const { config: r } = s;
+      if (r.cc) {
+        const E = `cc${r.cc}`;
+        i.settings[E] = {
+          min: r.min,
+          max: r.max,
+          invert: r.invert || !1,
+          is14Bit: r.is14Bit || !1,
+          label: n.getAttribute?.("data-midi-label") || null,
+          elementId: n.id || null
         };
       }
     }
-    return s;
+    return i;
   }
   /**
    * Apply a patch to the controller
@@ -2155,11 +2158,11 @@ class z extends H {
    * @returns {Promise<void>}
    * @throws {MIDIValidationError} If patch format is invalid
    */
-  async _setPatch(t) {
-    if (!t || !t.channels)
-      throw new L("Invalid patch format", "patch");
-    const s = t.version || "1.0";
-    s === "1.0" ? await this._applyPatchV1(t) : (console.warn(`Unknown patch version: ${s}. Attempting to apply as v1.0`), await this._applyPatchV1(t)), this.emit(C.PATCH_LOADED, { patch: t });
+  async _setPatch(e) {
+    if (!e || !e.channels)
+      throw new m("Invalid patch format", "patch");
+    const i = e.version || "1.0";
+    i === "1.0" ? await this._applyPatchV1(e) : (console.warn(`Unknown patch version: ${i}. Attempting to apply as v1.0`), await this._applyPatchV1(e)), this.emit(P.PATCH_LOADED, { patch: e });
   }
   /**
    * Apply patch data for version 1.0 format
@@ -2167,39 +2170,39 @@ class z extends H {
    * @param {PatchData} patch - Patch object to apply
    * @returns {Promise<void>}
    */
-  async _applyPatchV1(t) {
-    for (const [s, E] of Object.entries(t.channels)) {
-      const e = parseInt(s, 10);
-      if (E.ccs)
-        for (const [_, i] of Object.entries(E.ccs)) {
-          const r = parseInt(_, 10);
-          this._sendCC(r, i, e);
+  async _applyPatchV1(e) {
+    for (const [i, n] of Object.entries(e.channels)) {
+      const s = parseInt(i, 10);
+      if (n.ccs)
+        for (const [r, E] of Object.entries(n.ccs)) {
+          const o = parseInt(r, 10);
+          this._sendCC(o, E, s);
         }
-      if (E.program !== void 0 && this._sendPC(E.program, e), E.pitchBend !== void 0 && this._sendPitchBend(E.pitchBend, e), E.monoPressure !== void 0 && this._sendMonoPressure(E.monoPressure, e), E.polyPressure)
-        for (const [_, i] of Object.entries(E.polyPressure)) {
-          const r = parseInt(_, 10);
-          this._sendPolyPressure(r, i, e);
+      if (n.program !== void 0 && this._sendPC(n.program, s), n.pitchBend !== void 0 && this._sendPitchBend(n.pitchBend, s), n.monoPressure !== void 0 && this._sendMonoPressure(n.monoPressure, s), n.polyPressure)
+        for (const [r, E] of Object.entries(n.polyPressure)) {
+          const o = parseInt(r, 10);
+          this._sendPolyPressure(o, E, s);
         }
-      if (E.notes)
-        for (const [_, i] of Object.entries(E.notes)) {
-          const r = parseInt(_, 10);
-          i > 0 ? this._sendNoteOn(r, i, e) : this._sendNoteOff(r, e);
+      if (n.notes)
+        for (const [r, E] of Object.entries(n.notes)) {
+          const o = parseInt(r, 10);
+          E > 0 ? this._sendNoteOn(o, E, s) : this._sendNoteOff(o, s);
         }
     }
-    if (t.settings)
-      for (const [s, E] of Object.entries(t.settings))
-        for (const [e, _] of this.bindings.entries())
-          _.config.cc?.toString() === s.replace("cc", "") && (e.min !== void 0 && E.min !== void 0 && (e.min = String(E.min)), e.max !== void 0 && E.max !== void 0 && (e.max = String(E.max)));
-    for (const [s, E] of this.bindings.entries()) {
-      const { config: e } = E;
-      if (e.cc !== void 0) {
-        const _ = e.channel || this.options.inputChannel, i = t.channels[_];
-        if (i?.ccs) {
-          const r = i.ccs[e.cc];
-          if (r !== void 0) {
-            const u = e.min !== void 0 ? e.min : parseFloat(s.getAttribute?.("min")) || 0, S = e.max !== void 0 ? e.max : parseFloat(s.getAttribute?.("max")) || 127, P = e.invert || !1;
+    if (e.settings)
+      for (const [i, n] of Object.entries(e.settings))
+        for (const [s, r] of this.bindings.entries())
+          r.config.cc?.toString() === i.replace("cc", "") && (s.min !== void 0 && n.min !== void 0 && (s.min = String(n.min)), s.max !== void 0 && n.max !== void 0 && (s.max = String(n.max)));
+    for (const [i, n] of this.bindings.entries()) {
+      const { config: s } = n;
+      if (s.cc !== void 0) {
+        const r = s.channel || this.options.inputChannel, E = e.channels[r];
+        if (E?.ccs) {
+          const o = E.ccs[s.cc];
+          if (o !== void 0) {
+            const l = s.min !== void 0 ? s.min : parseFloat(i.getAttribute?.("min")) || 0, S = s.max !== void 0 ? s.max : parseFloat(i.getAttribute?.("max")) || 127, u = s.invert || !1;
             let a;
-            P ? a = S - r / 127 * (S - u) : a = u + r / 127 * (S - u), e.onInput && typeof e.onInput == "function" ? e.onInput(a) : (s.value = a, s.dispatchEvent(new Event("input", { bubbles: !0 })));
+            u ? a = S - o / 127 * (S - l) : a = l + o / 127 * (S - l), s.onInput && typeof s.onInput == "function" ? s.onInput(a) : (i.value = a, i.dispatchEvent(new Event("input", { bubbles: !0 })));
           }
         }
       }
@@ -2212,12 +2215,12 @@ class z extends H {
    * @param {PatchData} [patch] - Optional patch object (will use get() if not provided)
    * @returns {string} Storage key used
    */
-  _savePatch(t, s = null) {
-    const E = s || this._getPatch(t), e = `midiwire_patch_${t}`;
+  _savePatch(e, i = null) {
+    const n = i || this._getPatch(e), s = `midiwire_patch_${e}`;
     try {
-      return localStorage.setItem(e, JSON.stringify(E)), this.emit(C.PATCH_SAVED, { name: t, patch: E }), e;
-    } catch (_) {
-      throw console.error("Failed to save patch:", _), _;
+      return localStorage.setItem(s, JSON.stringify(n)), this.emit(P.PATCH_SAVED, { name: e, patch: n }), s;
+    } catch (r) {
+      throw console.error("Failed to save patch:", r), r;
     }
   }
   /**
@@ -2226,16 +2229,16 @@ class z extends H {
    * @param {string} name - Patch name
    * @returns {PatchData|null} Patch object or null if not found
    */
-  _loadPatch(t) {
-    const s = `midiwire_patch_${t}`;
+  _loadPatch(e) {
+    const i = `midiwire_patch_${e}`;
     try {
-      const E = localStorage.getItem(s);
-      if (!E)
+      const n = localStorage.getItem(i);
+      if (!n)
         return null;
-      const e = JSON.parse(E);
-      return this.emit(C.PATCH_LOADED, { name: t, patch: e }), e;
-    } catch (E) {
-      return console.error("Failed to load patch:", E), null;
+      const s = JSON.parse(n);
+      return this.emit(P.PATCH_LOADED, { name: e, patch: s }), s;
+    } catch (n) {
+      return console.error("Failed to load patch:", n), null;
     }
   }
   /**
@@ -2244,12 +2247,12 @@ class z extends H {
    * @param {string} name - Patch name
    * @returns {boolean} Success status
    */
-  _deletePatch(t) {
-    const s = `midiwire_patch_${t}`;
+  _deletePatch(e) {
+    const i = `midiwire_patch_${e}`;
     try {
-      return localStorage.removeItem(s), this.emit(C.PATCH_DELETED, { name: t }), !0;
-    } catch (E) {
-      return console.error("Failed to delete patch:", E), !1;
+      return localStorage.removeItem(i), this.emit(P.PATCH_DELETED, { name: e }), !0;
+    } catch (n) {
+      return console.error("Failed to delete patch:", n), !1;
     }
   }
   /**
@@ -2258,22 +2261,22 @@ class z extends H {
    * @returns {Array<{name: string, patch: PatchData}>} Sorted array of patch objects
    */
   _listPatches() {
-    const t = [];
+    const e = [];
     try {
-      for (let s = 0; s < localStorage.length; s++) {
-        const E = localStorage.key(s);
-        if (E?.startsWith("midiwire_patch_")) {
-          const e = E.replace("midiwire_patch_", ""), _ = this._loadPatch(e);
-          _ && t.push({ name: e, patch: _ });
+      for (let i = 0; i < localStorage.length; i++) {
+        const n = localStorage.key(i);
+        if (n?.startsWith("midiwire_patch_")) {
+          const s = n.replace("midiwire_patch_", ""), r = this._loadPatch(s);
+          r && e.push({ name: s, patch: r });
         }
       }
-    } catch (s) {
-      console.error("Failed to list patches:", s);
+    } catch (i) {
+      console.error("Failed to list patches:", i);
     }
-    return t.sort((s, E) => s.name.localeCompare(E.name));
+    return e.sort((i, n) => i.name.localeCompare(n.name));
   }
 }
-class q {
+class k {
   /**
    * Create a new MIDIDeviceManager instance
    * @param {Object} options - Configuration options
@@ -2282,10 +2285,10 @@ class q {
    * @param {Function} [options.onConnectionUpdate] - Callback when connection status changes (outputDevice: Object, inputDevice: Object, midi: MIDIController)
    * @param {number} [options.channel=1] - Default MIDI channel
    */
-  constructor(t = {}) {
-    this.midi = t.midiController || null, this.onStatusUpdate = t.onStatusUpdate || (() => {
-    }), this.onConnectionUpdate = t.onConnectionUpdate || (() => {
-    }), this.channel = t.channel || 1, this.currentOutput = null, this.currentInput = null, this.isConnecting = !1;
+  constructor(e = {}) {
+    this.midi = e.midiController || null, this.onStatusUpdate = e.onStatusUpdate || (() => {
+    }), this.onConnectionUpdate = e.onConnectionUpdate || (() => {
+    }), this.channel = e.channel || 1, this.currentOutput = null, this.currentInput = null, this.isConnecting = !1;
   }
   /**
    * Set up all MIDI device selectors in one call. Handles population, connection
@@ -2301,21 +2304,21 @@ class q {
    * @param {Function} [options.onDeviceListChange] - Called when device list changes (for custom UI updates)
    * @returns {Promise<MIDIController>} The MIDI controller instance for chaining
    */
-  async setupSelectors(t = {}, s = {}) {
+  async setupSelectors(e = {}, i = {}) {
     if (!this.midi)
       throw new Error("MIDI controller not initialized. Pass midiController in constructor options.");
-    const { output: E, input: e, channel: _ } = t, i = this._resolveSelector(E), r = this._resolveSelector(e), u = this._resolveSelector(_);
-    if (this._setupDeviceChangeListeners({ output: i, input: r }, s.onDeviceListChange), i) {
-      await this._populateOutputDeviceList(i);
-      const S = s.onConnect ? async (a, o) => s.onConnect({ midi: a, device: o, type: "output" }) : void 0, P = s.onDisconnect ? async (a) => s.onDisconnect({ midi: a, type: "output" }) : void 0;
-      this._connectOutputDeviceSelection(i, S, P);
+    const { output: n, input: s, channel: r } = e, E = this._resolveSelector(n), o = this._resolveSelector(s), l = this._resolveSelector(r);
+    if (this._setupDeviceChangeListeners({ output: E, input: o }, i.onDeviceListChange), E) {
+      await this._populateOutputDeviceList(E);
+      const S = i.onConnect ? async (a, A) => i.onConnect({ midi: a, device: A, type: "output" }) : void 0, u = i.onDisconnect ? async (a) => i.onDisconnect({ midi: a, type: "output" }) : void 0;
+      this._connectOutputDeviceSelection(E, S, u);
     }
-    if (r) {
-      await this._populateInputDeviceList(r);
-      const S = s.onConnect ? async (a, o) => s.onConnect({ midi: a, device: o, type: "input" }) : void 0, P = s.onDisconnect ? async (a) => s.onDisconnect({ midi: a, type: "input" }) : void 0;
-      this._connectInputDeviceSelection(r, S, P);
+    if (o) {
+      await this._populateInputDeviceList(o);
+      const S = i.onConnect ? async (a, A) => i.onConnect({ midi: a, device: A, type: "input" }) : void 0, u = i.onDisconnect ? async (a) => i.onDisconnect({ midi: a, type: "input" }) : void 0;
+      this._connectInputDeviceSelection(o, S, u);
     }
-    return u && this._connectChannelSelection(u, "output"), this.midi;
+    return l && this._connectChannelSelection(l, "output"), this.midi;
   }
   /**
    * Update status message and trigger status callback
@@ -2330,8 +2333,8 @@ class q {
    * @example
    * manager.updateStatus("Connection failed", "error");
    */
-  updateStatus(t, s = "") {
-    this.onStatusUpdate(t, s);
+  updateStatus(e, i = "") {
+    this.onStatusUpdate(e, i);
   }
   /**
    * Update connection status
@@ -2348,15 +2351,15 @@ class q {
    * @param {HTMLSelectElement} [selectElements.input] - Input device dropdown
    * @param {Function} [onDeviceListChange] - Callback when device list changes
    */
-  _setupDeviceChangeListeners(t = {}, s) {
-    !this.midi || this._listenersInitialized || (this._listenersInitialized = !0, this.midi.on(C.DEV_OUT_CONNECTED, async (E) => {
-      this.updateStatus(`Output device connected: ${E?.name || "Unknown"}`, "connected"), t.output && await this._populateOutputDeviceList(t.output), s && s();
-    }), this.midi.on(C.DEV_OUT_DISCONNECTED, async (E) => {
-      this.updateStatus(`Output device disconnected: ${E?.name || "Unknown"}`, "error"), this.currentOutput && E?.name === this.currentOutput.name && (this.currentOutput = null, this.updateConnectionStatus(), t.output && (t.output.value = "")), t.output && await this._populateOutputDeviceList(t.output), s && s();
-    }), this.midi.on(C.DEV_IN_CONNECTED, async (E) => {
-      this.updateStatus(`Input device connected: ${E?.name || "Unknown"}`, "connected"), t.input && await this._populateInputDeviceList(t.input), s && s();
-    }), this.midi.on(C.DEV_IN_DISCONNECTED, async (E) => {
-      this.updateStatus(`Input device disconnected: ${E?.name || "Unknown"}`, "error"), t.input && (t.input.value = "", await this._populateInputDeviceList(t.input)), s && s();
+  _setupDeviceChangeListeners(e = {}, i) {
+    !this.midi || this._listenersInitialized || (this._listenersInitialized = !0, this.midi.on(P.DEV_OUT_CONNECTED, async (n) => {
+      this.updateStatus(`Output device connected: ${n?.name || "Unknown"}`, "connected"), e.output && await this._populateOutputDeviceList(e.output), i && i();
+    }), this.midi.on(P.DEV_OUT_DISCONNECTED, async (n) => {
+      this.updateStatus(`Output device disconnected: ${n?.name || "Unknown"}`, "error"), this.currentOutput && n?.name === this.currentOutput.name && (this.currentOutput = null, this.updateConnectionStatus(), e.output && (e.output.value = "")), e.output && await this._populateOutputDeviceList(e.output), i && i();
+    }), this.midi.on(P.DEV_IN_CONNECTED, async (n) => {
+      this.updateStatus(`Input device connected: ${n?.name || "Unknown"}`, "connected"), e.input && await this._populateInputDeviceList(e.input), i && i();
+    }), this.midi.on(P.DEV_IN_DISCONNECTED, async (n) => {
+      this.updateStatus(`Input device disconnected: ${n?.name || "Unknown"}`, "error"), e.input && (e.input.value = "", await this._populateInputDeviceList(e.input)), i && i();
     }));
   }
   /**
@@ -2365,12 +2368,12 @@ class q {
    * @param {string|HTMLElement} selector - CSS selector string or DOM element
    * @returns {HTMLElement|null} The resolved element or null
    */
-  _resolveSelector(t) {
-    if (typeof t == "string") {
-      const s = document.querySelector(t);
-      return s || console.warn(`MIDIDeviceManager: Selector "${t}" not found`), s;
+  _resolveSelector(e) {
+    if (typeof e == "string") {
+      const i = document.querySelector(e);
+      return i || console.warn(`MIDIDeviceManager: Selector "${e}" not found`), i;
     }
-    return t || null;
+    return e || null;
   }
   /**
    * Get the current list of MIDI output devices
@@ -2397,23 +2400,23 @@ class q {
    * @param {Function} [onDisconnect] - Callback when device is disconnected (midi: MIDIController)
    * @returns {void}
    */
-  _connectOutputDeviceSelection(t, s, E) {
-    !t || !this.midi || t.addEventListener("change", async (e) => {
+  _connectOutputDeviceSelection(e, i, n) {
+    !e || !this.midi || e.addEventListener("change", async (s) => {
       if (this.isConnecting) return;
       this.isConnecting = !0;
-      const _ = e.target.value;
-      if (!_) {
-        this.currentOutput && this.midi && (await this.midi.device.disconnectOutput(), this.currentOutput = null, this.updateStatus("Output device disconnected", ""), this.updateConnectionStatus()), this.isConnecting = !1, E && await E(this.midi);
+      const r = s.target.value;
+      if (!r) {
+        this.currentOutput && this.midi && (await this.midi.device.disconnectOutput(), this.currentOutput = null, this.updateStatus("Output device disconnected", ""), this.updateConnectionStatus()), this.isConnecting = !1, n && await n(this.midi);
         return;
       }
       try {
-        if (await this.midi.device.connectOutput(parseInt(_, 10)), this.currentOutput = this.midi.device.getCurrentOutput(), this.currentOutput) {
-          const r = this.midi.device.getOutputs().findIndex((u) => u.id === this.currentOutput.id);
-          r !== -1 && (t.value = r.toString());
+        if (await this.midi.device.connectOutput(parseInt(r, 10)), this.currentOutput = this.midi.device.getCurrentOutput(), this.currentOutput) {
+          const o = this.midi.device.getOutputs().findIndex((l) => l.id === this.currentOutput.id);
+          o !== -1 && (e.value = o.toString());
         }
-        this.updateConnectionStatus(), s && await s(this.midi, this.currentOutput);
-      } catch (i) {
-        this.updateStatus(`Output connection failed: ${i.message}`, "error");
+        this.updateConnectionStatus(), i && await i(this.midi, this.currentOutput);
+      } catch (E) {
+        this.updateStatus(`Output connection failed: ${E.message}`, "error");
       } finally {
         this.isConnecting = !1;
       }
@@ -2428,21 +2431,21 @@ class q {
    * @param {Function} [onDisconnect] - Callback when device is disconnected (midi: MIDIController)
    * @returns {void}
    */
-  _connectInputDeviceSelection(t, s, E) {
-    !t || !this.midi || t.addEventListener("change", async (e) => {
-      const _ = e.target.value;
-      if (!_) {
-        this.midi && (await this.midi.device.disconnectInput(), this.updateStatus("Input device disconnected", ""), this.updateConnectionStatus()), E && await E(this.midi);
+  _connectInputDeviceSelection(e, i, n) {
+    !e || !this.midi || e.addEventListener("change", async (s) => {
+      const r = s.target.value;
+      if (!r) {
+        this.midi && (await this.midi.device.disconnectInput(), this.updateStatus("Input device disconnected", ""), this.updateConnectionStatus()), n && await n(this.midi);
         return;
       }
       if (!this.isConnecting) {
         this.isConnecting = !0;
         try {
-          await this.midi.device.connectInput(parseInt(_, 10));
-          const i = this.midi.device.getCurrentInput();
-          this.updateConnectionStatus(), s && await s(this.midi, i);
-        } catch (i) {
-          this.updateStatus(`Input connection failed: ${i.message}`, "error");
+          await this.midi.device.connectInput(parseInt(r, 10));
+          const E = this.midi.device.getCurrentInput();
+          this.updateConnectionStatus(), i && await i(this.midi, E);
+        } catch (E) {
+          this.updateStatus(`Input connection failed: ${E.message}`, "error");
         } finally {
           this.isConnecting = !1;
         }
@@ -2459,17 +2462,17 @@ class q {
    * @param {boolean} isOutput - Whether these are output devices
    * @returns {void}
    */
-  _populateDeviceList(t, s, E, e, _) {
-    if (s.length > 0) {
-      if (t.innerHTML = '<option value="">Select a device</option>' + s.map((i, r) => `<option value="${r}">${i.name}</option>`).join(""), E) {
-        const i = s.findIndex((r) => r.name === E.name);
-        i !== -1 ? t.value = i.toString() : (t.value = "", _ && (this.currentOutput = null, this.updateConnectionStatus()));
+  _populateDeviceList(e, i, n, s, r) {
+    if (i.length > 0) {
+      if (e.innerHTML = '<option value="">Select a device</option>' + i.map((E, o) => `<option value="${o}">${E.name}</option>`).join(""), n) {
+        const E = i.findIndex((o) => o.name === n.name);
+        E !== -1 ? e.value = E.toString() : (e.value = "", r && (this.currentOutput = null, this.updateConnectionStatus()));
       } else
-        t.value = "";
-      t.disabled = !1, _ && !this.currentOutput && this.updateStatus("Select a device");
+        e.value = "";
+      e.disabled = !1, r && !this.currentOutput && this.updateStatus("Select a device");
     } else
-      t.innerHTML = '<option value="">No devices connected</option>', t.disabled = !0, _ && this.updateStatus("No devices connected", "error");
-    e && e();
+      e.innerHTML = '<option value="">No devices connected</option>', e.disabled = !0, r && this.updateStatus("No devices connected", "error");
+    s && s();
   }
   /**
    * Populate a select element with available MIDI output devices. Automatically
@@ -2480,10 +2483,10 @@ class q {
    * @param {Function} [onChange] - Optional callback invoked after populating the list
    * @returns {Promise<void>}
    */
-  async _populateOutputDeviceList(t, s) {
-    if (!t || !this.midi) return;
-    const E = this._getOutputDevices();
-    this._populateDeviceList(t, E, this.currentOutput, s, !0);
+  async _populateOutputDeviceList(e, i) {
+    if (!e || !this.midi) return;
+    const n = this._getOutputDevices();
+    this._populateDeviceList(e, n, this.currentOutput, i, !0);
   }
   /**
    * Populate a select element with available MIDI input devices. Automatically
@@ -2494,10 +2497,10 @@ class q {
    * @param {Function} [onChange] - Optional callback invoked after populating the list
    * @returns {Promise<void>}
    */
-  async _populateInputDeviceList(t, s) {
-    if (!t || !this.midi) return;
-    const E = this._getInputDevices(), e = this.midi.device.getCurrentInput();
-    this._populateDeviceList(t, E, e, s, !1);
+  async _populateInputDeviceList(e, i) {
+    if (!e || !this.midi) return;
+    const n = this._getInputDevices(), s = this.midi.device.getCurrentInput();
+    this._populateDeviceList(e, n, s, i, !1);
   }
   /**
    * Connect channel selection events to automatically update the MIDI channel when
@@ -2519,199 +2522,15 @@ class q {
    * const inputChannelSelect = document.getElementById("input-channel-select");
    * manager.input.connectChannelSelection(inputChannelSelect);
    */
-  _connectChannelSelection(t, s) {
-    if (!t || !this.midi) return;
-    const E = s === "input" ? "inputChannel" : "outputChannel";
-    t.addEventListener("change", (e) => {
-      this.midi && (this.midi.options[E] = parseInt(e.target.value, 10), this.updateConnectionStatus());
+  _connectChannelSelection(e, i) {
+    if (!e || !this.midi) return;
+    const n = i === "input" ? "inputChannel" : "outputChannel";
+    e.addEventListener("change", (s) => {
+      this.midi && (this.midi.options[n] = parseInt(s.target.value, 10), this.updateConnectionStatus());
     });
   }
 }
-class n {
-  // Packed format (128 bytes)
-  // See: DX7 Service Manual, Voice Memory Format
-  static PACKED_SIZE = 128;
-  static PACKED_OP_SIZE = 17;
-  // 17 bytes per operator in packed format
-  static NUM_OPERATORS = 6;
-  // Packed operator parameter offsets (within each 17-byte operator block)
-  static PACKED_OP_EG_RATE_1 = 0;
-  static PACKED_OP_EG_RATE_2 = 1;
-  static PACKED_OP_EG_RATE_3 = 2;
-  static PACKED_OP_EG_RATE_4 = 3;
-  static PACKED_OP_EG_LEVEL_1 = 4;
-  static PACKED_OP_EG_LEVEL_2 = 5;
-  static PACKED_OP_EG_LEVEL_3 = 6;
-  static PACKED_OP_EG_LEVEL_4 = 7;
-  static PACKED_OP_BREAK_POINT = 8;
-  static PACKED_OP_L_SCALE_DEPTH = 9;
-  static PACKED_OP_R_SCALE_DEPTH = 10;
-  static PACKED_OP_CURVES = 11;
-  // LC and RC packed
-  static PACKED_OP_RATE_SCALING = 12;
-  // RS and DET packed
-  static PACKED_OP_MOD_SENS = 13;
-  // AMS and KVS packed
-  static PACKED_OP_OUTPUT_LEVEL = 14;
-  static PACKED_OP_MODE_FREQ = 15;
-  // Mode and Freq Coarse packed
-  static PACKED_OP_DETUNE_FINE = 16;
-  // OSC Detune and Freq Fine packed
-  // Packed voice offsets (after 6 operators = bytes 102+)
-  static PACKED_PITCH_EG_RATE_1 = 102;
-  static PACKED_PITCH_EG_RATE_2 = 103;
-  static PACKED_PITCH_EG_RATE_3 = 104;
-  static PACKED_PITCH_EG_RATE_4 = 105;
-  static PACKED_PITCH_EG_LEVEL_1 = 106;
-  static PACKED_PITCH_EG_LEVEL_2 = 107;
-  static PACKED_PITCH_EG_LEVEL_3 = 108;
-  static PACKED_PITCH_EG_LEVEL_4 = 109;
-  static OFFSET_ALGORITHM = 110;
-  static OFFSET_FEEDBACK = 111;
-  // Also contains OSC Sync
-  static OFFSET_LFO_SPEED = 112;
-  static OFFSET_LFO_DELAY = 113;
-  static OFFSET_LFO_PM_DEPTH = 114;
-  static OFFSET_LFO_AM_DEPTH = 115;
-  static OFFSET_LFO_SYNC_WAVE = 116;
-  // LFO sync, wave, and PM sensitivity packed
-  static OFFSET_TRANSPOSE = 117;
-  static OFFSET_AMP_MOD_SENS = 118;
-  static OFFSET_EG_BIAS_SENS = 119;
-  // Voice name (bytes 118-127)
-  // IMPORTANT: Byte 118 serves dual-purpose in DX7 hardware:
-  // 1. First character of voice name (as ASCII)
-  // 2. Amp Mod Sensitivity parameter (as numeric value 0-127)
-  // Both interpretations are used when converting to unpacked format
-  static PACKED_NAME_START = 118;
-  static NAME_LENGTH = 10;
-  // Unpacked format (169 bytes)
-  static UNPACKED_SIZE = 169;
-  // Total unpacked size (159 params + 10 name)
-  static UNPACKED_OP_SIZE = 23;
-  // 23 bytes per operator in unpacked format
-  // Unpacked operator parameter offsets (within each 23-byte operator block)
-  static UNPACKED_OP_EG_RATE_1 = 0;
-  static UNPACKED_OP_EG_RATE_2 = 1;
-  static UNPACKED_OP_EG_RATE_3 = 2;
-  static UNPACKED_OP_EG_RATE_4 = 3;
-  static UNPACKED_OP_EG_LEVEL_1 = 4;
-  static UNPACKED_OP_EG_LEVEL_2 = 5;
-  static UNPACKED_OP_EG_LEVEL_3 = 6;
-  static UNPACKED_OP_EG_LEVEL_4 = 7;
-  static UNPACKED_OP_BREAK_POINT = 8;
-  static UNPACKED_OP_L_SCALE_DEPTH = 9;
-  static UNPACKED_OP_R_SCALE_DEPTH = 10;
-  static UNPACKED_OP_L_CURVE = 11;
-  static UNPACKED_OP_R_CURVE = 12;
-  static UNPACKED_OP_RATE_SCALING = 13;
-  static UNPACKED_OP_DETUNE = 14;
-  static UNPACKED_OP_AMP_MOD_SENS = 15;
-  static UNPACKED_OP_OUTPUT_LEVEL = 16;
-  static UNPACKED_OP_MODE = 17;
-  // Mode (0=ratio, 1=fixed)
-  static UNPACKED_OP_KEY_VEL_SENS = 18;
-  static UNPACKED_OP_FREQ_COARSE = 19;
-  static UNPACKED_OP_OSC_DETUNE = 20;
-  static UNPACKED_OP_FREQ_FINE = 21;
-  // Unpacked pitch EG offsets (after 6 operators = index 138+)
-  static UNPACKED_PITCH_EG_RATE_1 = 138;
-  static UNPACKED_PITCH_EG_RATE_2 = 139;
-  static UNPACKED_PITCH_EG_RATE_3 = 140;
-  static UNPACKED_PITCH_EG_RATE_4 = 141;
-  static UNPACKED_PITCH_EG_LEVEL_1 = 142;
-  static UNPACKED_PITCH_EG_LEVEL_2 = 143;
-  static UNPACKED_PITCH_EG_LEVEL_3 = 144;
-  static UNPACKED_PITCH_EG_LEVEL_4 = 145;
-  // Unpacked global parameters (after pitch EG = index 146+)
-  static UNPACKED_ALGORITHM = 146;
-  static UNPACKED_FEEDBACK = 147;
-  static UNPACKED_OSC_SYNC = 148;
-  static UNPACKED_LFO_SPEED = 149;
-  static UNPACKED_LFO_DELAY = 150;
-  static UNPACKED_LFO_PM_DEPTH = 151;
-  static UNPACKED_LFO_AM_DEPTH = 152;
-  static UNPACKED_LFO_KEY_SYNC = 153;
-  static UNPACKED_LFO_WAVE = 154;
-  static UNPACKED_LFO_PM_SENS = 155;
-  static UNPACKED_AMP_MOD_SENS = 156;
-  static UNPACKED_TRANSPOSE = 157;
-  static UNPACKED_EG_BIAS_SENS = 158;
-  static UNPACKED_NAME_START = 159;
-  // VCED (single voice SysEx) format - for DX7 single patch dumps
-  static VCED_SIZE = 163;
-  // Total VCED sysex size (6 header + 155 data + 1 checksum + 1 end)
-  static VCED_HEADER_SIZE = 6;
-  static VCED_DATA_SIZE = 155;
-  // Voice data bytes (6 operators × 21 bytes + 8 pitch EG + 11 global + 10 name)
-  // VCED header bytes - DX7 single voice dump format
-  static VCED_SYSEX_START = 240;
-  // SysEx Message Start
-  static VCED_YAMAHA_ID = 67;
-  // Yamaha manufacturer ID
-  static VCED_SUB_STATUS = 0;
-  static VCED_FORMAT_SINGLE = 0;
-  // Single voice format identifier
-  static VCED_BYTE_COUNT_MSB = 1;
-  // High byte of data length (1)
-  static VCED_BYTE_COUNT_LSB = 27;
-  // Low byte of data length (27 in decimal = 155 bytes)
-  static VCED_SYSEX_END = 247;
-  // SysEx Message End
-  // Bit masks
-  static MASK_7BIT = 127;
-  // Standard 7-bit MIDI data mask
-  static MASK_2BIT = 3;
-  // For 2-bit values (curves)
-  static MASK_3BIT = 7;
-  // For 3-bit values (RS, detune)
-  static MASK_4BIT = 15;
-  // For 4-bit values (detune, fine freq)
-  static MASK_5BIT = 31;
-  // For 5-bit values (algorithm, freq coarse)
-  static MASK_1BIT = 1;
-  // For 1-bit values (mode, sync)
-  // Parameter value ranges
-  static TRANSPOSE_CENTER = 24;
-  // MIDI note 24 = C0 (center of DX7 transpose range: -24 to +24 semitones)
-  // Special character mappings - for Japanese DX7 character set compatibility
-  static CHAR_YEN = 92;
-  // Japanese Yen symbol (¥) maps to ASCII backslash
-  static CHAR_ARROW_RIGHT = 126;
-  // Right arrow (→) maps to ASCII tilde
-  static CHAR_ARROW_LEFT = 127;
-  // Left arrow (←) maps to ASCII DEL
-  static CHAR_REPLACEMENT_Y = 89;
-  // Replace Yen symbol with "Y"
-  static CHAR_REPLACEMENT_GT = 62;
-  // Right arrow with ">"
-  static CHAR_REPLACEMENT_LT = 60;
-  // Left arrow with "<"
-  static CHAR_SPACE = 32;
-  // Standard space character
-  static CHAR_MIN_PRINTABLE = 32;
-  // Minimum ASCII printable character
-  static CHAR_MAX_PRINTABLE = 126;
-  // Maximum ASCII printable character
-  // Default voice values
-  static DEFAULT_EG_RATE = 99;
-  static DEFAULT_EG_LEVEL_MAX = 99;
-  static DEFAULT_EG_LEVEL_MIN = 0;
-  static DEFAULT_BREAK_POINT = 0;
-  // DX7 breakpoint 0 = A-1 (MIDI note 9)
-  static DEFAULT_OUTPUT_LEVEL = 99;
-  static DEFAULT_PITCH_EG_LEVEL = 50;
-  static DEFAULT_LFO_SPEED = 35;
-  static DEFAULT_LFO_PM_SENS = 3;
-  static DEFAULT_DETUNE = 7;
-  // Detune center (actual detune = value - 7)
-  static DEFAULT_FREQ_COARSE = 1;
-  static DEFAULT_ALGORITHM = 0;
-  static DEFAULT_FEEDBACK = 0;
-  // MIDI notes
-  static MIDI_OCTAVE_OFFSET = -2;
-  // For displaying MIDI notes (MIDI 0 = C-2)
-  static MIDI_BREAK_POINT_OFFSET = 21;
+const t = class t {
   // Offset for breakpoint display
   /**
    * Create a DX7Voice from raw 128-byte data
@@ -2719,24 +2538,24 @@ class n {
    * @param {number} index - Voice index (0-31)
    * @throws {DX7ValidationError} If data length is not exactly 128 bytes
    */
-  constructor(t, s = 0) {
-    if (t.length !== n.PACKED_SIZE)
-      throw new c(
-        `Invalid voice data length: expected ${n.PACKED_SIZE} bytes, got ${t.length}`,
+  constructor(e, i = 0) {
+    if (e.length !== t.PACKED_SIZE)
+      throw new O(
+        `Invalid voice data length: expected ${t.PACKED_SIZE} bytes, got ${e.length}`,
         "length",
-        t.length
+        e.length
       );
-    this.index = s, this.data = new Uint8Array(t), this.name = this._extractName(), this._unpackedCache = null;
+    this.index = i, this.data = new Uint8Array(e), this.name = this._extractName(), this._unpackedCache = null;
   }
   /**
    * Extract the voice name from the data (10 characters at offset 118)
    * @private
    */
   _extractName() {
-    const t = this.data.subarray(n.PACKED_NAME_START, n.PACKED_NAME_START + n.NAME_LENGTH);
-    return Array.from(t).map((E) => {
-      let e = E & n.MASK_7BIT;
-      return e === n.CHAR_YEN && (e = n.CHAR_REPLACEMENT_Y), e === n.CHAR_ARROW_RIGHT && (e = n.CHAR_REPLACEMENT_GT), e === n.CHAR_ARROW_LEFT && (e = n.CHAR_REPLACEMENT_LT), (e < n.CHAR_MIN_PRINTABLE || e > n.CHAR_MAX_PRINTABLE) && (e = n.CHAR_SPACE), String.fromCharCode(e);
+    const e = this.data.subarray(t.PACKED_NAME_START, t.PACKED_NAME_START + t.NAME_LENGTH);
+    return Array.from(e).map((n) => {
+      let s = n & t.MASK_7BIT;
+      return s === t.CHAR_YEN && (s = t.CHAR_REPLACEMENT_Y), s === t.CHAR_ARROW_RIGHT && (s = t.CHAR_REPLACEMENT_GT), s === t.CHAR_ARROW_LEFT && (s = t.CHAR_REPLACEMENT_LT), (s < t.CHAR_MIN_PRINTABLE || s > t.CHAR_MAX_PRINTABLE) && (s = t.CHAR_SPACE), String.fromCharCode(s);
     }).join("").trim();
   }
   /**
@@ -2745,14 +2564,14 @@ class n {
    * @returns {number} Parameter value (0-127)
    * @throws {DX7ValidationError} If offset is out of range
    */
-  getParameter(t) {
-    if (t < 0 || t >= n.PACKED_SIZE)
-      throw new c(
-        `Parameter offset out of range: ${t} (must be 0-${n.PACKED_SIZE - 1})`,
+  getParameter(e) {
+    if (e < 0 || e >= t.PACKED_SIZE)
+      throw new O(
+        `Parameter offset out of range: ${e} (must be 0-${t.PACKED_SIZE - 1})`,
         "offset",
-        t
+        e
       );
-    return this.data[t] & n.MASK_7BIT;
+    return this.data[e] & t.MASK_7BIT;
   }
   /**
    * Get a parameter value from the unpacked 169-byte format
@@ -2760,28 +2579,28 @@ class n {
    * @returns {number} Parameter value (0-127)
    * @throws {DX7ValidationError} If offset is out of range
    */
-  getUnpackedParameter(t) {
-    if (t < 0 || t >= n.UNPACKED_SIZE)
-      throw new c(
-        `Unpacked parameter offset out of range: ${t} (must be 0-${n.UNPACKED_SIZE - 1})`,
+  getUnpackedParameter(e) {
+    if (e < 0 || e >= t.UNPACKED_SIZE)
+      throw new O(
+        `Unpacked parameter offset out of range: ${e} (must be 0-${t.UNPACKED_SIZE - 1})`,
         "offset",
-        t
+        e
       );
-    return this._unpackedCache || (this._unpackedCache = this.unpack()), this._unpackedCache[t] & n.MASK_7BIT;
+    return this._unpackedCache || (this._unpackedCache = this.unpack()), this._unpackedCache[e] & t.MASK_7BIT;
   }
   /**
    * Set a raw parameter value in the packed data
    * @param {number} offset - Byte offset in the voice data
    * @param {number} value - Parameter value (0-127)
    */
-  setParameter(t, s) {
-    if (t < 0 || t >= n.PACKED_SIZE)
-      throw new c(
-        `Parameter offset out of range: ${t} (must be 0-${n.PACKED_SIZE - 1})`,
+  setParameter(e, i) {
+    if (e < 0 || e >= t.PACKED_SIZE)
+      throw new O(
+        `Parameter offset out of range: ${e} (must be 0-${t.PACKED_SIZE - 1})`,
         "offset",
-        t
+        e
       );
-    this.data[t] = s & n.MASK_7BIT, this._unpackedCache = null, t >= n.PACKED_NAME_START && t < n.PACKED_NAME_START + n.NAME_LENGTH && (this.name = this._extractName());
+    this.data[e] = i & t.MASK_7BIT, this._unpackedCache = null, e >= t.PACKED_NAME_START && e < t.PACKED_NAME_START + t.NAME_LENGTH && (this.name = this._extractName());
   }
   /**
    * Unpack the voice data to 169-byte unpacked format
@@ -2789,199 +2608,199 @@ class n {
    * @returns {Uint8Array} 169 bytes of unpacked voice data (138 operator + 8 pitch EG + 13 global + 10 name = 169 bytes)
    */
   unpack() {
-    const t = this.data, s = new Uint8Array(n.UNPACKED_SIZE);
-    return this._unpackOperators(t, s), this._unpackPitchEG(t, s), this._unpackGlobalParams(t, s), this._unpackName(t, s), s;
+    const e = this.data, i = new Uint8Array(t.UNPACKED_SIZE);
+    return this._unpackOperators(e, i), this._unpackPitchEG(e, i), this._unpackGlobalParams(e, i), this._unpackName(e, i), i;
   }
   /**
    * Unpack all 6 operators from packed to unpacked format
    * @private
    */
-  _unpackOperators(t, s) {
-    for (let E = 0; E < n.NUM_OPERATORS; E++) {
-      const e = (n.NUM_OPERATORS - 1 - E) * n.PACKED_OP_SIZE, _ = E * n.UNPACKED_OP_SIZE;
-      this._unpackOperator(t, s, e, _);
+  _unpackOperators(e, i) {
+    for (let n = 0; n < t.NUM_OPERATORS; n++) {
+      const s = (t.NUM_OPERATORS - 1 - n) * t.PACKED_OP_SIZE, r = n * t.UNPACKED_OP_SIZE;
+      this._unpackOperator(e, i, s, r);
     }
   }
   /**
    * Unpack a single operator's parameters
    * @private
    */
-  _unpackOperator(t, s, E, e) {
-    this._unpackOperatorEG(t, s, E, e), this._unpackOperatorScaling(t, s, E, e), this._unpackOperatorPackedParams(t, s, E, e), this._unpackOperatorFrequency(t, s, E, e);
+  _unpackOperator(e, i, n, s) {
+    this._unpackOperatorEG(e, i, n, s), this._unpackOperatorScaling(e, i, n, s), this._unpackOperatorPackedParams(e, i, n, s), this._unpackOperatorFrequency(e, i, n, s);
   }
   /**
    * Unpack operator EG rates and levels
    * @private
    */
-  _unpackOperatorEG(t, s, E, e) {
-    s[e + n.UNPACKED_OP_EG_RATE_1] = t[E + n.PACKED_OP_EG_RATE_1] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_RATE_2] = t[E + n.PACKED_OP_EG_RATE_2] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_RATE_3] = t[E + n.PACKED_OP_EG_RATE_3] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_RATE_4] = t[E + n.PACKED_OP_EG_RATE_4] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_LEVEL_1] = t[E + n.PACKED_OP_EG_LEVEL_1] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_LEVEL_2] = t[E + n.PACKED_OP_EG_LEVEL_2] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_LEVEL_3] = t[E + n.PACKED_OP_EG_LEVEL_3] & n.MASK_7BIT, s[e + n.UNPACKED_OP_EG_LEVEL_4] = t[E + n.PACKED_OP_EG_LEVEL_4] & n.MASK_7BIT;
+  _unpackOperatorEG(e, i, n, s) {
+    i[s + t.UNPACKED_OP_EG_RATE_1] = e[n + t.PACKED_OP_EG_RATE_1] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_RATE_2] = e[n + t.PACKED_OP_EG_RATE_2] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_RATE_3] = e[n + t.PACKED_OP_EG_RATE_3] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_RATE_4] = e[n + t.PACKED_OP_EG_RATE_4] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_LEVEL_1] = e[n + t.PACKED_OP_EG_LEVEL_1] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_LEVEL_2] = e[n + t.PACKED_OP_EG_LEVEL_2] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_LEVEL_3] = e[n + t.PACKED_OP_EG_LEVEL_3] & t.MASK_7BIT, i[s + t.UNPACKED_OP_EG_LEVEL_4] = e[n + t.PACKED_OP_EG_LEVEL_4] & t.MASK_7BIT;
   }
   /**
    * Unpack operator keyboard scaling parameters
    * @private
    */
-  _unpackOperatorScaling(t, s, E, e) {
-    s[e + n.UNPACKED_OP_BREAK_POINT] = t[E + n.PACKED_OP_BREAK_POINT] & n.MASK_7BIT, s[e + n.UNPACKED_OP_L_SCALE_DEPTH] = t[E + n.PACKED_OP_L_SCALE_DEPTH] & n.MASK_7BIT, s[e + n.UNPACKED_OP_R_SCALE_DEPTH] = t[E + n.PACKED_OP_R_SCALE_DEPTH] & n.MASK_7BIT;
+  _unpackOperatorScaling(e, i, n, s) {
+    i[s + t.UNPACKED_OP_BREAK_POINT] = e[n + t.PACKED_OP_BREAK_POINT] & t.MASK_7BIT, i[s + t.UNPACKED_OP_L_SCALE_DEPTH] = e[n + t.PACKED_OP_L_SCALE_DEPTH] & t.MASK_7BIT, i[s + t.UNPACKED_OP_R_SCALE_DEPTH] = e[n + t.PACKED_OP_R_SCALE_DEPTH] & t.MASK_7BIT;
   }
   /**
    * Unpack operator bit-packed parameters (curves, rate scaling, mod sens)
    * @private
    */
-  _unpackOperatorPackedParams(t, s, E, e) {
-    const _ = t[E + n.PACKED_OP_CURVES] & n.MASK_7BIT;
-    s[e + n.UNPACKED_OP_L_CURVE] = _ & n.MASK_2BIT, s[e + n.UNPACKED_OP_R_CURVE] = _ >> 2 & n.MASK_2BIT;
-    const i = t[E + n.PACKED_OP_RATE_SCALING] & n.MASK_7BIT;
-    s[e + n.UNPACKED_OP_RATE_SCALING] = i & n.MASK_3BIT, s[e + n.UNPACKED_OP_DETUNE] = i >> 3 & n.MASK_4BIT;
-    const r = t[E + n.PACKED_OP_MOD_SENS] & n.MASK_7BIT;
-    s[e + n.UNPACKED_OP_AMP_MOD_SENS] = r & n.MASK_2BIT, s[e + n.UNPACKED_OP_KEY_VEL_SENS] = r >> 2 & n.MASK_3BIT, s[e + n.UNPACKED_OP_OUTPUT_LEVEL] = t[E + n.PACKED_OP_OUTPUT_LEVEL] & n.MASK_7BIT;
+  _unpackOperatorPackedParams(e, i, n, s) {
+    const r = e[n + t.PACKED_OP_CURVES] & t.MASK_7BIT;
+    i[s + t.UNPACKED_OP_L_CURVE] = r & t.MASK_2BIT, i[s + t.UNPACKED_OP_R_CURVE] = r >> 2 & t.MASK_2BIT;
+    const E = e[n + t.PACKED_OP_RATE_SCALING] & t.MASK_7BIT;
+    i[s + t.UNPACKED_OP_RATE_SCALING] = E & t.MASK_3BIT, i[s + t.UNPACKED_OP_DETUNE] = E >> 3 & t.MASK_4BIT;
+    const o = e[n + t.PACKED_OP_MOD_SENS] & t.MASK_7BIT;
+    i[s + t.UNPACKED_OP_AMP_MOD_SENS] = o & t.MASK_2BIT, i[s + t.UNPACKED_OP_KEY_VEL_SENS] = o >> 2 & t.MASK_3BIT, i[s + t.UNPACKED_OP_OUTPUT_LEVEL] = e[n + t.PACKED_OP_OUTPUT_LEVEL] & t.MASK_7BIT;
   }
   /**
    * Unpack operator frequency parameters
    * @private
    */
-  _unpackOperatorFrequency(t, s, E, e) {
-    const _ = t[E + n.PACKED_OP_MODE_FREQ] & n.MASK_7BIT;
-    s[e + n.UNPACKED_OP_MODE] = _ & n.MASK_1BIT, s[e + n.UNPACKED_OP_FREQ_COARSE] = _ >> 1 & n.MASK_5BIT;
-    const i = t[E + n.PACKED_OP_DETUNE_FINE] & n.MASK_7BIT;
-    s[e + n.UNPACKED_OP_OSC_DETUNE] = i & n.MASK_3BIT, s[e + n.UNPACKED_OP_FREQ_FINE] = i >> 3 & n.MASK_4BIT;
+  _unpackOperatorFrequency(e, i, n, s) {
+    const r = e[n + t.PACKED_OP_MODE_FREQ] & t.MASK_7BIT;
+    i[s + t.UNPACKED_OP_MODE] = r & t.MASK_1BIT, i[s + t.UNPACKED_OP_FREQ_COARSE] = r >> 1 & t.MASK_5BIT;
+    const E = e[n + t.PACKED_OP_DETUNE_FINE] & t.MASK_7BIT;
+    i[s + t.UNPACKED_OP_OSC_DETUNE] = E & t.MASK_3BIT, i[s + t.UNPACKED_OP_FREQ_FINE] = E >> 3 & t.MASK_4BIT;
   }
   /**
    * Unpack pitch envelope generator parameters
    * @private
    */
-  _unpackPitchEG(t, s) {
-    s[n.UNPACKED_PITCH_EG_RATE_1] = t[n.PACKED_PITCH_EG_RATE_1] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_RATE_2] = t[n.PACKED_PITCH_EG_RATE_2] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_RATE_3] = t[n.PACKED_PITCH_EG_RATE_3] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_RATE_4] = t[n.PACKED_PITCH_EG_RATE_4] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_LEVEL_1] = t[n.PACKED_PITCH_EG_LEVEL_1] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_LEVEL_2] = t[n.PACKED_PITCH_EG_LEVEL_2] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_LEVEL_3] = t[n.PACKED_PITCH_EG_LEVEL_3] & n.MASK_7BIT, s[n.UNPACKED_PITCH_EG_LEVEL_4] = t[n.PACKED_PITCH_EG_LEVEL_4] & n.MASK_7BIT;
+  _unpackPitchEG(e, i) {
+    i[t.UNPACKED_PITCH_EG_RATE_1] = e[t.PACKED_PITCH_EG_RATE_1] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_RATE_2] = e[t.PACKED_PITCH_EG_RATE_2] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_RATE_3] = e[t.PACKED_PITCH_EG_RATE_3] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_RATE_4] = e[t.PACKED_PITCH_EG_RATE_4] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_LEVEL_1] = e[t.PACKED_PITCH_EG_LEVEL_1] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_LEVEL_2] = e[t.PACKED_PITCH_EG_LEVEL_2] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_LEVEL_3] = e[t.PACKED_PITCH_EG_LEVEL_3] & t.MASK_7BIT, i[t.UNPACKED_PITCH_EG_LEVEL_4] = e[t.PACKED_PITCH_EG_LEVEL_4] & t.MASK_7BIT;
   }
   /**
    * Unpack global voice parameters (algorithm, feedback, LFO, etc.)
    * @private
    */
-  _unpackGlobalParams(t, s) {
-    s[n.UNPACKED_ALGORITHM] = t[n.OFFSET_ALGORITHM] & n.MASK_5BIT;
-    const E = t[n.OFFSET_FEEDBACK] & n.MASK_7BIT;
-    s[n.UNPACKED_FEEDBACK] = E & n.MASK_3BIT, s[n.UNPACKED_OSC_SYNC] = E >> 3 & n.MASK_1BIT, s[n.UNPACKED_LFO_SPEED] = t[n.OFFSET_LFO_SPEED] & n.MASK_7BIT, s[n.UNPACKED_LFO_DELAY] = t[n.OFFSET_LFO_DELAY] & n.MASK_7BIT, s[n.UNPACKED_LFO_PM_DEPTH] = t[n.OFFSET_LFO_PM_DEPTH] & n.MASK_7BIT, s[n.UNPACKED_LFO_AM_DEPTH] = t[n.OFFSET_LFO_AM_DEPTH] & n.MASK_7BIT;
-    const e = t[n.OFFSET_LFO_SYNC_WAVE] & n.MASK_7BIT;
-    s[n.UNPACKED_LFO_KEY_SYNC] = e & n.MASK_1BIT, s[n.UNPACKED_LFO_WAVE] = e >> 1 & n.MASK_3BIT, s[n.UNPACKED_LFO_PM_SENS] = e >> 4 & n.MASK_3BIT, s[n.UNPACKED_AMP_MOD_SENS] = t[n.OFFSET_AMP_MOD_SENS] & n.MASK_7BIT, s[n.UNPACKED_TRANSPOSE] = t[n.OFFSET_TRANSPOSE] & n.MASK_7BIT, s[n.UNPACKED_EG_BIAS_SENS] = t[n.OFFSET_EG_BIAS_SENS] & n.MASK_7BIT;
+  _unpackGlobalParams(e, i) {
+    i[t.UNPACKED_ALGORITHM] = e[t.OFFSET_ALGORITHM] & t.MASK_5BIT;
+    const n = e[t.OFFSET_FEEDBACK] & t.MASK_7BIT;
+    i[t.UNPACKED_FEEDBACK] = n & t.MASK_3BIT, i[t.UNPACKED_OSC_SYNC] = n >> 3 & t.MASK_1BIT, i[t.UNPACKED_LFO_SPEED] = e[t.OFFSET_LFO_SPEED] & t.MASK_7BIT, i[t.UNPACKED_LFO_DELAY] = e[t.OFFSET_LFO_DELAY] & t.MASK_7BIT, i[t.UNPACKED_LFO_PM_DEPTH] = e[t.OFFSET_LFO_PM_DEPTH] & t.MASK_7BIT, i[t.UNPACKED_LFO_AM_DEPTH] = e[t.OFFSET_LFO_AM_DEPTH] & t.MASK_7BIT;
+    const s = e[t.OFFSET_LFO_SYNC_WAVE] & t.MASK_7BIT;
+    i[t.UNPACKED_LFO_KEY_SYNC] = s & t.MASK_1BIT, i[t.UNPACKED_LFO_WAVE] = s >> 1 & t.MASK_3BIT, i[t.UNPACKED_LFO_PM_SENS] = s >> 4 & t.MASK_3BIT, i[t.UNPACKED_AMP_MOD_SENS] = e[t.OFFSET_AMP_MOD_SENS] & t.MASK_7BIT, i[t.UNPACKED_TRANSPOSE] = e[t.OFFSET_TRANSPOSE] & t.MASK_7BIT, i[t.UNPACKED_EG_BIAS_SENS] = e[t.OFFSET_EG_BIAS_SENS] & t.MASK_7BIT;
   }
   /**
    * Copy voice name from packed to unpacked format
    * @private
    */
-  _unpackName(t, s) {
-    for (let E = 0; E < n.NAME_LENGTH; E++)
-      s[n.UNPACKED_NAME_START + E] = t[n.PACKED_NAME_START + E] & n.MASK_7BIT;
+  _unpackName(e, i) {
+    for (let n = 0; n < t.NAME_LENGTH; n++)
+      i[t.UNPACKED_NAME_START + n] = e[t.PACKED_NAME_START + n] & t.MASK_7BIT;
   }
   /**
    * Pack 169-byte unpacked data to 128-byte format
    * @param {Array<number>|Uint8Array} unpacked - 169 bytes of unpacked data (159 parameters + 10 name bytes)
    * @returns {Uint8Array} 128 bytes of packed data
    */
-  static pack(t) {
-    if (t.length !== n.UNPACKED_SIZE)
-      throw new c(
-        `Invalid unpacked data length: expected ${n.UNPACKED_SIZE} bytes, got ${t.length}`,
+  static pack(e) {
+    if (e.length !== t.UNPACKED_SIZE)
+      throw new O(
+        `Invalid unpacked data length: expected ${t.UNPACKED_SIZE} bytes, got ${e.length}`,
         "length",
-        t.length
+        e.length
       );
-    const s = new Uint8Array(n.PACKED_SIZE);
-    return n._packOperators(t, s), n._packPitchEG(t, s), n._packGlobalParams(t, s), n._packName(t, s), s;
+    const i = new Uint8Array(t.PACKED_SIZE);
+    return t._packOperators(e, i), t._packPitchEG(e, i), t._packGlobalParams(e, i), t._packName(e, i), i;
   }
   /**
    * Pack all 6 operators from unpacked to packed format
    * @private
    */
-  static _packOperators(t, s) {
-    for (let E = 0; E < n.NUM_OPERATORS; E++) {
-      const e = E * n.UNPACKED_OP_SIZE, _ = (n.NUM_OPERATORS - 1 - E) * n.PACKED_OP_SIZE;
-      n._packOperator(t, s, e, _);
+  static _packOperators(e, i) {
+    for (let n = 0; n < t.NUM_OPERATORS; n++) {
+      const s = n * t.UNPACKED_OP_SIZE, r = (t.NUM_OPERATORS - 1 - n) * t.PACKED_OP_SIZE;
+      t._packOperator(e, i, s, r);
     }
   }
   /**
    * Pack a single operator's parameters
    * @private
    */
-  static _packOperator(t, s, E, e) {
-    n._packOperatorEG(t, s, E, e), n._packOperatorScaling(t, s, E, e), n._packOperatorPackedParams(t, s, E, e), n._packOperatorFrequency(t, s, E, e);
+  static _packOperator(e, i, n, s) {
+    t._packOperatorEG(e, i, n, s), t._packOperatorScaling(e, i, n, s), t._packOperatorPackedParams(e, i, n, s), t._packOperatorFrequency(e, i, n, s);
   }
   /**
    * Pack operator EG rates and levels
    * @private
    */
-  static _packOperatorEG(t, s, E, e) {
-    s[e + n.PACKED_OP_EG_RATE_1] = t[E + n.UNPACKED_OP_EG_RATE_1], s[e + n.PACKED_OP_EG_RATE_2] = t[E + n.UNPACKED_OP_EG_RATE_2], s[e + n.PACKED_OP_EG_RATE_3] = t[E + n.UNPACKED_OP_EG_RATE_3], s[e + n.PACKED_OP_EG_RATE_4] = t[E + n.UNPACKED_OP_EG_RATE_4], s[e + n.PACKED_OP_EG_LEVEL_1] = t[E + n.UNPACKED_OP_EG_LEVEL_1], s[e + n.PACKED_OP_EG_LEVEL_2] = t[E + n.UNPACKED_OP_EG_LEVEL_2], s[e + n.PACKED_OP_EG_LEVEL_3] = t[E + n.UNPACKED_OP_EG_LEVEL_3], s[e + n.PACKED_OP_EG_LEVEL_4] = t[E + n.UNPACKED_OP_EG_LEVEL_4];
+  static _packOperatorEG(e, i, n, s) {
+    i[s + t.PACKED_OP_EG_RATE_1] = e[n + t.UNPACKED_OP_EG_RATE_1], i[s + t.PACKED_OP_EG_RATE_2] = e[n + t.UNPACKED_OP_EG_RATE_2], i[s + t.PACKED_OP_EG_RATE_3] = e[n + t.UNPACKED_OP_EG_RATE_3], i[s + t.PACKED_OP_EG_RATE_4] = e[n + t.UNPACKED_OP_EG_RATE_4], i[s + t.PACKED_OP_EG_LEVEL_1] = e[n + t.UNPACKED_OP_EG_LEVEL_1], i[s + t.PACKED_OP_EG_LEVEL_2] = e[n + t.UNPACKED_OP_EG_LEVEL_2], i[s + t.PACKED_OP_EG_LEVEL_3] = e[n + t.UNPACKED_OP_EG_LEVEL_3], i[s + t.PACKED_OP_EG_LEVEL_4] = e[n + t.UNPACKED_OP_EG_LEVEL_4];
   }
   /**
    * Pack operator keyboard scaling parameters
    * @private
    */
-  static _packOperatorScaling(t, s, E, e) {
-    s[e + n.PACKED_OP_BREAK_POINT] = t[E + n.UNPACKED_OP_BREAK_POINT], s[e + n.PACKED_OP_L_SCALE_DEPTH] = t[E + n.UNPACKED_OP_L_SCALE_DEPTH], s[e + n.PACKED_OP_R_SCALE_DEPTH] = t[E + n.UNPACKED_OP_R_SCALE_DEPTH];
+  static _packOperatorScaling(e, i, n, s) {
+    i[s + t.PACKED_OP_BREAK_POINT] = e[n + t.UNPACKED_OP_BREAK_POINT], i[s + t.PACKED_OP_L_SCALE_DEPTH] = e[n + t.UNPACKED_OP_L_SCALE_DEPTH], i[s + t.PACKED_OP_R_SCALE_DEPTH] = e[n + t.UNPACKED_OP_R_SCALE_DEPTH];
   }
   /**
    * Pack operator bit-packed parameters
    * @private
    */
-  static _packOperatorPackedParams(t, s, E, e) {
-    const _ = t[E + n.UNPACKED_OP_L_CURVE] & n.MASK_2BIT, i = t[E + n.UNPACKED_OP_R_CURVE] & n.MASK_2BIT;
-    s[e + n.PACKED_OP_CURVES] = _ | i << 2;
-    const r = t[E + n.UNPACKED_OP_RATE_SCALING] & n.MASK_3BIT, u = t[E + n.UNPACKED_OP_DETUNE] & n.MASK_4BIT;
-    s[e + n.PACKED_OP_RATE_SCALING] = r | u << 3;
-    const S = t[E + n.UNPACKED_OP_AMP_MOD_SENS] & n.MASK_2BIT, P = t[E + n.UNPACKED_OP_KEY_VEL_SENS] & n.MASK_3BIT;
-    s[e + n.PACKED_OP_MOD_SENS] = S | P << 2, s[e + n.PACKED_OP_OUTPUT_LEVEL] = t[E + n.UNPACKED_OP_OUTPUT_LEVEL];
+  static _packOperatorPackedParams(e, i, n, s) {
+    const r = e[n + t.UNPACKED_OP_L_CURVE] & t.MASK_2BIT, E = e[n + t.UNPACKED_OP_R_CURVE] & t.MASK_2BIT;
+    i[s + t.PACKED_OP_CURVES] = r | E << 2;
+    const o = e[n + t.UNPACKED_OP_RATE_SCALING] & t.MASK_3BIT, l = e[n + t.UNPACKED_OP_DETUNE] & t.MASK_4BIT;
+    i[s + t.PACKED_OP_RATE_SCALING] = o | l << 3;
+    const S = e[n + t.UNPACKED_OP_AMP_MOD_SENS] & t.MASK_2BIT, u = e[n + t.UNPACKED_OP_KEY_VEL_SENS] & t.MASK_3BIT;
+    i[s + t.PACKED_OP_MOD_SENS] = S | u << 2, i[s + t.PACKED_OP_OUTPUT_LEVEL] = e[n + t.UNPACKED_OP_OUTPUT_LEVEL];
   }
   /**
    * Pack operator frequency parameters
    * @private
    */
-  static _packOperatorFrequency(t, s, E, e) {
-    const _ = t[E + n.UNPACKED_OP_MODE] & n.MASK_1BIT, i = t[E + n.UNPACKED_OP_FREQ_COARSE] & n.MASK_5BIT;
-    s[e + n.PACKED_OP_MODE_FREQ] = _ | i << 1;
-    const r = t[E + n.UNPACKED_OP_OSC_DETUNE] & n.MASK_3BIT, u = t[E + n.UNPACKED_OP_FREQ_FINE] & n.MASK_4BIT;
-    s[e + n.PACKED_OP_DETUNE_FINE] = r | u << 3;
+  static _packOperatorFrequency(e, i, n, s) {
+    const r = e[n + t.UNPACKED_OP_MODE] & t.MASK_1BIT, E = e[n + t.UNPACKED_OP_FREQ_COARSE] & t.MASK_5BIT;
+    i[s + t.PACKED_OP_MODE_FREQ] = r | E << 1;
+    const o = e[n + t.UNPACKED_OP_OSC_DETUNE] & t.MASK_3BIT, l = e[n + t.UNPACKED_OP_FREQ_FINE] & t.MASK_4BIT;
+    i[s + t.PACKED_OP_DETUNE_FINE] = o | l << 3;
   }
   /**
    * Pack pitch envelope generator parameters
    * @private
    */
-  static _packPitchEG(t, s) {
-    s[n.PACKED_PITCH_EG_RATE_1] = t[n.UNPACKED_PITCH_EG_RATE_1], s[n.PACKED_PITCH_EG_RATE_2] = t[n.UNPACKED_PITCH_EG_RATE_2], s[n.PACKED_PITCH_EG_RATE_3] = t[n.UNPACKED_PITCH_EG_RATE_3], s[n.PACKED_PITCH_EG_RATE_4] = t[n.UNPACKED_PITCH_EG_RATE_4], s[n.PACKED_PITCH_EG_LEVEL_1] = t[n.UNPACKED_PITCH_EG_LEVEL_1], s[n.PACKED_PITCH_EG_LEVEL_2] = t[n.UNPACKED_PITCH_EG_LEVEL_2], s[n.PACKED_PITCH_EG_LEVEL_3] = t[n.UNPACKED_PITCH_EG_LEVEL_3], s[n.PACKED_PITCH_EG_LEVEL_4] = t[n.UNPACKED_PITCH_EG_LEVEL_4];
+  static _packPitchEG(e, i) {
+    i[t.PACKED_PITCH_EG_RATE_1] = e[t.UNPACKED_PITCH_EG_RATE_1], i[t.PACKED_PITCH_EG_RATE_2] = e[t.UNPACKED_PITCH_EG_RATE_2], i[t.PACKED_PITCH_EG_RATE_3] = e[t.UNPACKED_PITCH_EG_RATE_3], i[t.PACKED_PITCH_EG_RATE_4] = e[t.UNPACKED_PITCH_EG_RATE_4], i[t.PACKED_PITCH_EG_LEVEL_1] = e[t.UNPACKED_PITCH_EG_LEVEL_1], i[t.PACKED_PITCH_EG_LEVEL_2] = e[t.UNPACKED_PITCH_EG_LEVEL_2], i[t.PACKED_PITCH_EG_LEVEL_3] = e[t.UNPACKED_PITCH_EG_LEVEL_3], i[t.PACKED_PITCH_EG_LEVEL_4] = e[t.UNPACKED_PITCH_EG_LEVEL_4];
   }
   /**
    * Pack global voice parameters (algorithm, feedback, LFO, etc.)
    * @private
    */
-  static _packGlobalParams(t, s) {
-    s[n.OFFSET_ALGORITHM] = t[n.UNPACKED_ALGORITHM];
-    const E = t[n.UNPACKED_FEEDBACK] & n.MASK_3BIT, e = t[n.UNPACKED_OSC_SYNC] & n.MASK_1BIT;
-    s[n.OFFSET_FEEDBACK] = E | e << 3, s[n.OFFSET_LFO_SPEED] = t[n.UNPACKED_LFO_SPEED], s[n.OFFSET_LFO_DELAY] = t[n.UNPACKED_LFO_DELAY], s[n.OFFSET_LFO_PM_DEPTH] = t[n.UNPACKED_LFO_PM_DEPTH], s[n.OFFSET_LFO_AM_DEPTH] = t[n.UNPACKED_LFO_AM_DEPTH];
-    const _ = t[n.UNPACKED_LFO_KEY_SYNC] & n.MASK_1BIT, i = t[n.UNPACKED_LFO_WAVE] & n.MASK_3BIT, r = t[n.UNPACKED_LFO_PM_SENS] & n.MASK_3BIT;
-    s[n.OFFSET_LFO_SYNC_WAVE] = _ | i << 1 | r << 4, s[n.OFFSET_AMP_MOD_SENS] = t[n.UNPACKED_AMP_MOD_SENS], s[n.OFFSET_TRANSPOSE] = t[n.UNPACKED_TRANSPOSE], s[n.OFFSET_EG_BIAS_SENS] = t[n.UNPACKED_EG_BIAS_SENS];
+  static _packGlobalParams(e, i) {
+    i[t.OFFSET_ALGORITHM] = e[t.UNPACKED_ALGORITHM];
+    const n = e[t.UNPACKED_FEEDBACK] & t.MASK_3BIT, s = e[t.UNPACKED_OSC_SYNC] & t.MASK_1BIT;
+    i[t.OFFSET_FEEDBACK] = n | s << 3, i[t.OFFSET_LFO_SPEED] = e[t.UNPACKED_LFO_SPEED], i[t.OFFSET_LFO_DELAY] = e[t.UNPACKED_LFO_DELAY], i[t.OFFSET_LFO_PM_DEPTH] = e[t.UNPACKED_LFO_PM_DEPTH], i[t.OFFSET_LFO_AM_DEPTH] = e[t.UNPACKED_LFO_AM_DEPTH];
+    const r = e[t.UNPACKED_LFO_KEY_SYNC] & t.MASK_1BIT, E = e[t.UNPACKED_LFO_WAVE] & t.MASK_3BIT, o = e[t.UNPACKED_LFO_PM_SENS] & t.MASK_3BIT;
+    i[t.OFFSET_LFO_SYNC_WAVE] = r | E << 1 | o << 4, i[t.OFFSET_AMP_MOD_SENS] = e[t.UNPACKED_AMP_MOD_SENS], i[t.OFFSET_TRANSPOSE] = e[t.UNPACKED_TRANSPOSE], i[t.OFFSET_EG_BIAS_SENS] = e[t.UNPACKED_EG_BIAS_SENS];
   }
   /**
    * Copy voice name from unpacked to packed format
    * @private
    */
-  static _packName(t, s) {
-    for (let E = 0; E < n.NAME_LENGTH; E++)
-      s[n.PACKED_NAME_START + E] = t[n.UNPACKED_NAME_START + E];
+  static _packName(e, i) {
+    for (let n = 0; n < t.NAME_LENGTH; n++)
+      i[t.PACKED_NAME_START + n] = e[t.UNPACKED_NAME_START + n];
   }
   /**
    * Create a default/empty voice
    * @param {number} index - Voice index
    * @returns {DX7Voice}
    */
-  static createDefault(t = 0) {
-    const s = new Uint8Array(n.UNPACKED_SIZE);
-    for (let _ = 0; _ < n.NUM_OPERATORS; _++) {
-      const i = _ * n.UNPACKED_OP_SIZE;
-      s[i + n.UNPACKED_OP_EG_RATE_1] = n.DEFAULT_EG_RATE, s[i + n.UNPACKED_OP_EG_RATE_2] = n.DEFAULT_EG_RATE, s[i + n.UNPACKED_OP_EG_RATE_3] = n.DEFAULT_EG_RATE, s[i + n.UNPACKED_OP_EG_RATE_4] = n.DEFAULT_EG_RATE, s[i + n.UNPACKED_OP_EG_LEVEL_1] = n.DEFAULT_EG_LEVEL_MAX, s[i + n.UNPACKED_OP_EG_LEVEL_2] = n.DEFAULT_EG_LEVEL_MAX, s[i + n.UNPACKED_OP_EG_LEVEL_3] = n.DEFAULT_EG_LEVEL_MAX, s[i + n.UNPACKED_OP_EG_LEVEL_4] = n.DEFAULT_EG_LEVEL_MIN, s[i + n.UNPACKED_OP_BREAK_POINT] = n.DEFAULT_BREAK_POINT, s[i + n.UNPACKED_OP_L_SCALE_DEPTH] = 0, s[i + n.UNPACKED_OP_R_SCALE_DEPTH] = 0, s[i + n.UNPACKED_OP_L_CURVE] = 0, s[i + n.UNPACKED_OP_R_CURVE] = 0, s[i + n.UNPACKED_OP_RATE_SCALING] = 0, s[i + n.UNPACKED_OP_DETUNE] = n.DEFAULT_DETUNE, s[i + n.UNPACKED_OP_AMP_MOD_SENS] = 0, s[i + n.UNPACKED_OP_KEY_VEL_SENS] = 0, s[i + n.UNPACKED_OP_OUTPUT_LEVEL] = n.DEFAULT_OUTPUT_LEVEL, s[i + n.UNPACKED_OP_MODE] = 0, s[i + n.UNPACKED_OP_FREQ_COARSE] = n.DEFAULT_FREQ_COARSE, s[i + n.UNPACKED_OP_OSC_DETUNE] = 0, s[i + n.UNPACKED_OP_FREQ_FINE] = 0;
+  static createDefault(e = 0) {
+    const i = new Uint8Array(t.UNPACKED_SIZE);
+    for (let r = 0; r < t.NUM_OPERATORS; r++) {
+      const E = r * t.UNPACKED_OP_SIZE;
+      i[E + t.UNPACKED_OP_EG_RATE_1] = t.DEFAULT_EG_RATE, i[E + t.UNPACKED_OP_EG_RATE_2] = t.DEFAULT_EG_RATE, i[E + t.UNPACKED_OP_EG_RATE_3] = t.DEFAULT_EG_RATE, i[E + t.UNPACKED_OP_EG_RATE_4] = t.DEFAULT_EG_RATE, i[E + t.UNPACKED_OP_EG_LEVEL_1] = t.DEFAULT_EG_LEVEL_MAX, i[E + t.UNPACKED_OP_EG_LEVEL_2] = t.DEFAULT_EG_LEVEL_MAX, i[E + t.UNPACKED_OP_EG_LEVEL_3] = t.DEFAULT_EG_LEVEL_MAX, i[E + t.UNPACKED_OP_EG_LEVEL_4] = t.DEFAULT_EG_LEVEL_MIN, i[E + t.UNPACKED_OP_BREAK_POINT] = t.DEFAULT_BREAK_POINT, i[E + t.UNPACKED_OP_L_SCALE_DEPTH] = 0, i[E + t.UNPACKED_OP_R_SCALE_DEPTH] = 0, i[E + t.UNPACKED_OP_L_CURVE] = 0, i[E + t.UNPACKED_OP_R_CURVE] = 0, i[E + t.UNPACKED_OP_RATE_SCALING] = 0, i[E + t.UNPACKED_OP_DETUNE] = t.DEFAULT_DETUNE, i[E + t.UNPACKED_OP_AMP_MOD_SENS] = 0, i[E + t.UNPACKED_OP_KEY_VEL_SENS] = 0, i[E + t.UNPACKED_OP_OUTPUT_LEVEL] = t.DEFAULT_OUTPUT_LEVEL, i[E + t.UNPACKED_OP_MODE] = 0, i[E + t.UNPACKED_OP_FREQ_COARSE] = t.DEFAULT_FREQ_COARSE, i[E + t.UNPACKED_OP_OSC_DETUNE] = 0, i[E + t.UNPACKED_OP_FREQ_FINE] = 0;
     }
-    s[n.UNPACKED_PITCH_EG_RATE_1] = n.DEFAULT_EG_RATE, s[n.UNPACKED_PITCH_EG_RATE_2] = n.DEFAULT_EG_RATE, s[n.UNPACKED_PITCH_EG_RATE_3] = n.DEFAULT_EG_RATE, s[n.UNPACKED_PITCH_EG_RATE_4] = n.DEFAULT_EG_RATE, s[n.UNPACKED_PITCH_EG_LEVEL_1] = n.DEFAULT_PITCH_EG_LEVEL, s[n.UNPACKED_PITCH_EG_LEVEL_2] = n.DEFAULT_PITCH_EG_LEVEL, s[n.UNPACKED_PITCH_EG_LEVEL_3] = n.DEFAULT_PITCH_EG_LEVEL, s[n.UNPACKED_PITCH_EG_LEVEL_4] = n.DEFAULT_PITCH_EG_LEVEL, s[n.UNPACKED_ALGORITHM] = n.DEFAULT_ALGORITHM, s[n.UNPACKED_FEEDBACK] = n.DEFAULT_FEEDBACK, s[n.UNPACKED_OSC_SYNC] = 0, s[n.UNPACKED_LFO_SPEED] = n.DEFAULT_LFO_SPEED, s[n.UNPACKED_LFO_DELAY] = 0, s[n.UNPACKED_LFO_PM_DEPTH] = 0, s[n.UNPACKED_LFO_AM_DEPTH] = 0, s[n.UNPACKED_LFO_KEY_SYNC] = 0, s[n.UNPACKED_LFO_WAVE] = 0, s[n.UNPACKED_LFO_PM_SENS] = n.DEFAULT_LFO_PM_SENS, s[n.UNPACKED_AMP_MOD_SENS] = 0, s[n.UNPACKED_TRANSPOSE] = n.TRANSPOSE_CENTER, s[n.UNPACKED_EG_BIAS_SENS] = 0;
-    const E = "Init Voice";
-    for (let _ = 0; _ < n.NAME_LENGTH; _++)
-      s[n.UNPACKED_NAME_START + _] = _ < E.length ? E.charCodeAt(_) : n.CHAR_SPACE;
-    const e = n.pack(s);
-    return new n(e, t);
+    i[t.UNPACKED_PITCH_EG_RATE_1] = t.DEFAULT_EG_RATE, i[t.UNPACKED_PITCH_EG_RATE_2] = t.DEFAULT_EG_RATE, i[t.UNPACKED_PITCH_EG_RATE_3] = t.DEFAULT_EG_RATE, i[t.UNPACKED_PITCH_EG_RATE_4] = t.DEFAULT_EG_RATE, i[t.UNPACKED_PITCH_EG_LEVEL_1] = t.DEFAULT_PITCH_EG_LEVEL, i[t.UNPACKED_PITCH_EG_LEVEL_2] = t.DEFAULT_PITCH_EG_LEVEL, i[t.UNPACKED_PITCH_EG_LEVEL_3] = t.DEFAULT_PITCH_EG_LEVEL, i[t.UNPACKED_PITCH_EG_LEVEL_4] = t.DEFAULT_PITCH_EG_LEVEL, i[t.UNPACKED_ALGORITHM] = t.DEFAULT_ALGORITHM, i[t.UNPACKED_FEEDBACK] = t.DEFAULT_FEEDBACK, i[t.UNPACKED_OSC_SYNC] = t.DEFAULT_OSC_SYNC, i[t.UNPACKED_LFO_SPEED] = t.DEFAULT_LFO_SPEED, i[t.UNPACKED_LFO_DELAY] = 0, i[t.UNPACKED_LFO_PM_DEPTH] = 0, i[t.UNPACKED_LFO_AM_DEPTH] = 0, i[t.UNPACKED_LFO_KEY_SYNC] = t.DEFAULT_LFO_KEY_SYNC, i[t.UNPACKED_LFO_WAVE] = 0, i[t.UNPACKED_LFO_PM_SENS] = t.DEFAULT_LFO_PM_SENS, i[t.UNPACKED_AMP_MOD_SENS] = 0, i[t.UNPACKED_TRANSPOSE] = t.TRANSPOSE_CENTER, i[t.UNPACKED_EG_BIAS_SENS] = 0;
+    const n = "Init Voice";
+    for (let r = 0; r < t.NAME_LENGTH; r++)
+      i[t.UNPACKED_NAME_START + r] = r < n.length ? n.charCodeAt(r) : t.CHAR_SPACE;
+    const s = t.pack(i);
+    return new t(s, e);
   }
   /**
    * Create a voice from unpacked 169-byte data
@@ -2989,9 +2808,9 @@ class n {
    * @param {number} index - Voice index
    * @returns {DX7Voice}
    */
-  static fromUnpacked(t, s = 0) {
-    const E = n.pack(t);
-    return new n(E, s);
+  static fromUnpacked(e, i = 0) {
+    const n = t.pack(e);
+    return new t(n, i);
   }
   /**
    * Load a DX7 voice from a single voice SYX file
@@ -3000,38 +2819,38 @@ class n {
    * @throws {DX7ParseError} If file has invalid VCED header
    * @throws {Error} If file cannot be read (FileReader error)
    */
-  static async fromFile(t) {
-    return new Promise((s, E) => {
-      const e = new FileReader();
-      e.onload = (_) => {
+  static async fromFile(e) {
+    return new Promise((i, n) => {
+      const s = new FileReader();
+      s.onload = (r) => {
         try {
-          const i = new Uint8Array(_.target.result);
-          if (i[0] !== n.VCED_SYSEX_START || i[1] !== n.VCED_YAMAHA_ID || i[2] !== n.VCED_SUB_STATUS || i[3] !== n.VCED_FORMAT_SINGLE || i[4] !== n.VCED_BYTE_COUNT_MSB || i[5] !== n.VCED_BYTE_COUNT_LSB)
-            throw new m("Invalid VCED header", "header", 0);
-          const r = i.subarray(
-            n.VCED_HEADER_SIZE,
-            n.VCED_HEADER_SIZE + n.VCED_DATA_SIZE
-          ), u = i[n.VCED_HEADER_SIZE + n.VCED_DATA_SIZE], S = l._calculateChecksum(r, n.VCED_DATA_SIZE);
-          u !== S && console.warn(
-            `DX7 VCED checksum mismatch (expected ${S.toString(16)}, got ${u.toString(16)}). This is common with vintage SysEx files.`
+          const E = new Uint8Array(r.target.result);
+          if (E[0] !== t.VCED_SYSEX_START || E[1] !== t.VCED_YAMAHA_ID || E[2] !== t.VCED_SUB_STATUS || E[3] !== t.VCED_FORMAT_SINGLE || E[4] !== t.VCED_BYTE_COUNT_MSB || E[5] !== t.VCED_BYTE_COUNT_LSB)
+            throw new R("Invalid VCED header", "header", 0);
+          const o = E.subarray(
+            t.VCED_HEADER_SIZE,
+            t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE
+          ), l = E[t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE], S = M._calculateChecksum(o, t.VCED_DATA_SIZE);
+          l !== S && console.warn(
+            `DX7 VCED checksum mismatch (expected ${S.toString(16)}, got ${l.toString(16)}). This is common with vintage SysEx files.`
           );
-          const P = new Uint8Array(n.UNPACKED_SIZE);
+          const u = new Uint8Array(t.UNPACKED_SIZE);
           let a = 0;
-          for (let h = 0; h < n.NUM_OPERATORS; h++) {
-            const N = (n.NUM_OPERATORS - 1 - h) * n.UNPACKED_OP_SIZE;
-            P[N + n.UNPACKED_OP_EG_RATE_1] = r[a++], P[N + n.UNPACKED_OP_EG_RATE_2] = r[a++], P[N + n.UNPACKED_OP_EG_RATE_3] = r[a++], P[N + n.UNPACKED_OP_EG_RATE_4] = r[a++], P[N + n.UNPACKED_OP_EG_LEVEL_1] = r[a++], P[N + n.UNPACKED_OP_EG_LEVEL_2] = r[a++], P[N + n.UNPACKED_OP_EG_LEVEL_3] = r[a++], P[N + n.UNPACKED_OP_EG_LEVEL_4] = r[a++], P[N + n.UNPACKED_OP_BREAK_POINT] = r[a++], P[N + n.UNPACKED_OP_L_SCALE_DEPTH] = r[a++], P[N + n.UNPACKED_OP_R_SCALE_DEPTH] = r[a++], P[N + n.UNPACKED_OP_L_CURVE] = r[a++], P[N + n.UNPACKED_OP_R_CURVE] = r[a++], P[N + n.UNPACKED_OP_RATE_SCALING] = r[a++], P[N + n.UNPACKED_OP_DETUNE] = r[a++];
-            const d = r[a++];
-            P[N + n.UNPACKED_OP_AMP_MOD_SENS] = d & n.MASK_2BIT, P[N + n.UNPACKED_OP_KEY_VEL_SENS] = d >> 2 & n.MASK_3BIT, P[N + n.UNPACKED_OP_OUTPUT_LEVEL] = r[a++], P[N + n.UNPACKED_OP_MODE] = r[a++], P[N + n.UNPACKED_OP_FREQ_COARSE] = r[a++], P[N + n.UNPACKED_OP_FREQ_FINE] = r[a++], P[N + n.UNPACKED_OP_OSC_DETUNE] = r[a++];
+          for (let h = 0; h < t.NUM_OPERATORS; h++) {
+            const N = (t.NUM_OPERATORS - 1 - h) * t.UNPACKED_OP_SIZE;
+            u[N + t.UNPACKED_OP_EG_RATE_1] = o[a++], u[N + t.UNPACKED_OP_EG_RATE_2] = o[a++], u[N + t.UNPACKED_OP_EG_RATE_3] = o[a++], u[N + t.UNPACKED_OP_EG_RATE_4] = o[a++], u[N + t.UNPACKED_OP_EG_LEVEL_1] = o[a++], u[N + t.UNPACKED_OP_EG_LEVEL_2] = o[a++], u[N + t.UNPACKED_OP_EG_LEVEL_3] = o[a++], u[N + t.UNPACKED_OP_EG_LEVEL_4] = o[a++], u[N + t.UNPACKED_OP_BREAK_POINT] = o[a++], u[N + t.UNPACKED_OP_L_SCALE_DEPTH] = o[a++], u[N + t.UNPACKED_OP_R_SCALE_DEPTH] = o[a++], u[N + t.UNPACKED_OP_L_CURVE] = o[a++], u[N + t.UNPACKED_OP_R_CURVE] = o[a++], u[N + t.UNPACKED_OP_RATE_SCALING] = o[a++], u[N + t.UNPACKED_OP_DETUNE] = o[a++];
+            const d = o[a++];
+            u[N + t.UNPACKED_OP_AMP_MOD_SENS] = d & t.MASK_2BIT, u[N + t.UNPACKED_OP_KEY_VEL_SENS] = d >> 2 & t.MASK_3BIT, u[N + t.UNPACKED_OP_OUTPUT_LEVEL] = o[a++], u[N + t.UNPACKED_OP_MODE] = o[a++], u[N + t.UNPACKED_OP_FREQ_COARSE] = o[a++], u[N + t.UNPACKED_OP_FREQ_FINE] = o[a++], u[N + t.UNPACKED_OP_OSC_DETUNE] = o[a++];
           }
-          P[n.UNPACKED_PITCH_EG_RATE_1] = r[a++], P[n.UNPACKED_PITCH_EG_RATE_2] = r[a++], P[n.UNPACKED_PITCH_EG_RATE_3] = r[a++], P[n.UNPACKED_PITCH_EG_RATE_4] = r[a++], P[n.UNPACKED_PITCH_EG_LEVEL_1] = r[a++], P[n.UNPACKED_PITCH_EG_LEVEL_2] = r[a++], P[n.UNPACKED_PITCH_EG_LEVEL_3] = r[a++], P[n.UNPACKED_PITCH_EG_LEVEL_4] = r[a++], P[n.UNPACKED_ALGORITHM] = r[a++], P[n.UNPACKED_FEEDBACK] = r[a++], P[n.UNPACKED_OSC_SYNC] = r[a++], P[n.UNPACKED_LFO_SPEED] = r[a++], P[n.UNPACKED_LFO_DELAY] = r[a++], P[n.UNPACKED_LFO_PM_DEPTH] = r[a++], P[n.UNPACKED_LFO_AM_DEPTH] = r[a++], P[n.UNPACKED_LFO_KEY_SYNC] = r[a++], P[n.UNPACKED_LFO_WAVE] = r[a++], P[n.UNPACKED_LFO_PM_SENS] = r[a++], P[n.UNPACKED_TRANSPOSE] = r[a++];
-          for (let h = 0; h < n.NAME_LENGTH; h++)
-            P[n.UNPACKED_NAME_START + h] = r[a++];
-          const o = n.pack(P);
-          s(new n(o, 0));
-        } catch (i) {
-          E(i);
+          u[t.UNPACKED_PITCH_EG_RATE_1] = o[a++], u[t.UNPACKED_PITCH_EG_RATE_2] = o[a++], u[t.UNPACKED_PITCH_EG_RATE_3] = o[a++], u[t.UNPACKED_PITCH_EG_RATE_4] = o[a++], u[t.UNPACKED_PITCH_EG_LEVEL_1] = o[a++], u[t.UNPACKED_PITCH_EG_LEVEL_2] = o[a++], u[t.UNPACKED_PITCH_EG_LEVEL_3] = o[a++], u[t.UNPACKED_PITCH_EG_LEVEL_4] = o[a++], u[t.UNPACKED_ALGORITHM] = o[a++], u[t.UNPACKED_FEEDBACK] = o[a++], u[t.UNPACKED_OSC_SYNC] = o[a++], u[t.UNPACKED_LFO_SPEED] = o[a++], u[t.UNPACKED_LFO_DELAY] = o[a++], u[t.UNPACKED_LFO_PM_DEPTH] = o[a++], u[t.UNPACKED_LFO_AM_DEPTH] = o[a++], u[t.UNPACKED_LFO_KEY_SYNC] = o[a++], u[t.UNPACKED_LFO_WAVE] = o[a++], u[t.UNPACKED_LFO_PM_SENS] = o[a++], u[t.UNPACKED_TRANSPOSE] = o[a++];
+          for (let h = 0; h < t.NAME_LENGTH; h++)
+            u[t.UNPACKED_NAME_START + h] = o[a++];
+          const A = t.pack(u);
+          i(new t(A, 0));
+        } catch (E) {
+          n(E);
         }
-      }, e.onerror = () => E(new Error("Failed to read file")), e.readAsArrayBuffer(t);
+      }, s.onerror = () => n(new Error("Failed to read file")), s.readAsArrayBuffer(e);
     });
   }
   /**
@@ -3042,43 +2861,43 @@ class n {
    * @throws {DX7ParseError} If VCED header is invalid
    * @throws {DX7ValidationError} If data length is invalid
    */
-  static fromSysEx(t, s = 0) {
-    const E = t instanceof Uint8Array ? t : new Uint8Array(t);
-    let e;
-    if (E[0] === n.VCED_SYSEX_START) {
-      if (E[0] !== n.VCED_SYSEX_START || E[1] !== n.VCED_YAMAHA_ID || E[2] !== n.VCED_SUB_STATUS || E[3] !== n.VCED_FORMAT_SINGLE || E[4] !== n.VCED_BYTE_COUNT_MSB || E[5] !== n.VCED_BYTE_COUNT_LSB)
-        throw new m("Invalid VCED header", "header", 0);
-      e = E.subarray(n.VCED_HEADER_SIZE, n.VCED_HEADER_SIZE + n.VCED_DATA_SIZE);
-    } else if (E.length === n.PACKED_SIZE)
-      e = E;
+  static fromSysEx(e, i = 0) {
+    const n = e instanceof Uint8Array ? e : new Uint8Array(e);
+    let s;
+    if (n[0] === t.VCED_SYSEX_START) {
+      if (n[0] !== t.VCED_SYSEX_START || n[1] !== t.VCED_YAMAHA_ID || n[2] !== t.VCED_SUB_STATUS || n[3] !== t.VCED_FORMAT_SINGLE || n[4] !== t.VCED_BYTE_COUNT_MSB || n[5] !== t.VCED_BYTE_COUNT_LSB)
+        throw new R("Invalid VCED header", "header", 0);
+      s = n.subarray(t.VCED_HEADER_SIZE, t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE);
+    } else if (n.length === t.PACKED_SIZE)
+      s = n;
     else
-      throw new c(
-        `Invalid data length: expected ${n.PACKED_SIZE} or ${n.VCED_SIZE} bytes, got ${E.length}`,
+      throw new O(
+        `Invalid data length: expected ${t.PACKED_SIZE} or ${t.VCED_SIZE} bytes, got ${n.length}`,
         "length",
-        E.length
+        n.length
       );
-    if (e.length !== n.VCED_DATA_SIZE && e.length !== n.PACKED_SIZE)
-      throw new c(
-        `Invalid voice data length: expected ${n.VCED_DATA_SIZE} or ${n.PACKED_SIZE} bytes, got ${e.length}`,
+    if (s.length !== t.VCED_DATA_SIZE && s.length !== t.PACKED_SIZE)
+      throw new O(
+        `Invalid voice data length: expected ${t.VCED_DATA_SIZE} or ${t.PACKED_SIZE} bytes, got ${s.length}`,
         "length",
-        e.length
+        s.length
       );
-    if (e.length === n.VCED_DATA_SIZE) {
-      const _ = new Uint8Array(n.UNPACKED_SIZE);
-      let i = 0;
-      for (let u = 0; u < n.NUM_OPERATORS; u++) {
-        const S = (n.NUM_OPERATORS - 1 - u) * n.UNPACKED_OP_SIZE;
-        _[S + n.UNPACKED_OP_EG_RATE_1] = e[i++], _[S + n.UNPACKED_OP_EG_RATE_2] = e[i++], _[S + n.UNPACKED_OP_EG_RATE_3] = e[i++], _[S + n.UNPACKED_OP_EG_RATE_4] = e[i++], _[S + n.UNPACKED_OP_EG_LEVEL_1] = e[i++], _[S + n.UNPACKED_OP_EG_LEVEL_2] = e[i++], _[S + n.UNPACKED_OP_EG_LEVEL_3] = e[i++], _[S + n.UNPACKED_OP_EG_LEVEL_4] = e[i++], _[S + n.UNPACKED_OP_BREAK_POINT] = e[i++], _[S + n.UNPACKED_OP_L_SCALE_DEPTH] = e[i++], _[S + n.UNPACKED_OP_R_SCALE_DEPTH] = e[i++], _[S + n.UNPACKED_OP_L_CURVE] = e[i++], _[S + n.UNPACKED_OP_R_CURVE] = e[i++], _[S + n.UNPACKED_OP_RATE_SCALING] = e[i++], _[S + n.UNPACKED_OP_DETUNE] = e[i++];
-        const P = e[i++];
-        _[S + n.UNPACKED_OP_AMP_MOD_SENS] = P & n.MASK_2BIT, _[S + n.UNPACKED_OP_KEY_VEL_SENS] = P >> 2 & n.MASK_3BIT, _[S + n.UNPACKED_OP_OUTPUT_LEVEL] = e[i++], _[S + n.UNPACKED_OP_MODE] = e[i++], _[S + n.UNPACKED_OP_FREQ_COARSE] = e[i++], _[S + n.UNPACKED_OP_FREQ_FINE] = e[i++], _[S + n.UNPACKED_OP_OSC_DETUNE] = e[i++];
+    if (s.length === t.VCED_DATA_SIZE) {
+      const r = new Uint8Array(t.UNPACKED_SIZE);
+      let E = 0;
+      for (let l = 0; l < t.NUM_OPERATORS; l++) {
+        const S = (t.NUM_OPERATORS - 1 - l) * t.UNPACKED_OP_SIZE;
+        r[S + t.UNPACKED_OP_EG_RATE_1] = s[E++], r[S + t.UNPACKED_OP_EG_RATE_2] = s[E++], r[S + t.UNPACKED_OP_EG_RATE_3] = s[E++], r[S + t.UNPACKED_OP_EG_RATE_4] = s[E++], r[S + t.UNPACKED_OP_EG_LEVEL_1] = s[E++], r[S + t.UNPACKED_OP_EG_LEVEL_2] = s[E++], r[S + t.UNPACKED_OP_EG_LEVEL_3] = s[E++], r[S + t.UNPACKED_OP_EG_LEVEL_4] = s[E++], r[S + t.UNPACKED_OP_BREAK_POINT] = s[E++], r[S + t.UNPACKED_OP_L_SCALE_DEPTH] = s[E++], r[S + t.UNPACKED_OP_R_SCALE_DEPTH] = s[E++], r[S + t.UNPACKED_OP_L_CURVE] = s[E++], r[S + t.UNPACKED_OP_R_CURVE] = s[E++], r[S + t.UNPACKED_OP_RATE_SCALING] = s[E++], r[S + t.UNPACKED_OP_DETUNE] = s[E++];
+        const u = s[E++];
+        r[S + t.UNPACKED_OP_AMP_MOD_SENS] = u & t.MASK_2BIT, r[S + t.UNPACKED_OP_KEY_VEL_SENS] = u >> 2 & t.MASK_3BIT, r[S + t.UNPACKED_OP_OUTPUT_LEVEL] = s[E++], r[S + t.UNPACKED_OP_MODE] = s[E++], r[S + t.UNPACKED_OP_FREQ_COARSE] = s[E++], r[S + t.UNPACKED_OP_FREQ_FINE] = s[E++], r[S + t.UNPACKED_OP_OSC_DETUNE] = s[E++];
       }
-      _[n.UNPACKED_PITCH_EG_RATE_1] = e[i++], _[n.UNPACKED_PITCH_EG_RATE_2] = e[i++], _[n.UNPACKED_PITCH_EG_RATE_3] = e[i++], _[n.UNPACKED_PITCH_EG_RATE_4] = e[i++], _[n.UNPACKED_PITCH_EG_LEVEL_1] = e[i++], _[n.UNPACKED_PITCH_EG_LEVEL_2] = e[i++], _[n.UNPACKED_PITCH_EG_LEVEL_3] = e[i++], _[n.UNPACKED_PITCH_EG_LEVEL_4] = e[i++], _[n.UNPACKED_ALGORITHM] = e[i++], _[n.UNPACKED_FEEDBACK] = e[i++], _[n.UNPACKED_OSC_SYNC] = e[i++], _[n.UNPACKED_LFO_SPEED] = e[i++], _[n.UNPACKED_LFO_DELAY] = e[i++], _[n.UNPACKED_LFO_PM_DEPTH] = e[i++], _[n.UNPACKED_LFO_AM_DEPTH] = e[i++], _[n.UNPACKED_LFO_KEY_SYNC] = e[i++], _[n.UNPACKED_LFO_WAVE] = e[i++], _[n.UNPACKED_LFO_PM_SENS] = e[i++], _[n.UNPACKED_TRANSPOSE] = e[i++];
-      for (let u = 0; u < n.NAME_LENGTH; u++)
-        _[n.UNPACKED_NAME_START + u] = e[i++];
-      const r = n.pack(_);
-      return new n(r, s);
+      r[t.UNPACKED_PITCH_EG_RATE_1] = s[E++], r[t.UNPACKED_PITCH_EG_RATE_2] = s[E++], r[t.UNPACKED_PITCH_EG_RATE_3] = s[E++], r[t.UNPACKED_PITCH_EG_RATE_4] = s[E++], r[t.UNPACKED_PITCH_EG_LEVEL_1] = s[E++], r[t.UNPACKED_PITCH_EG_LEVEL_2] = s[E++], r[t.UNPACKED_PITCH_EG_LEVEL_3] = s[E++], r[t.UNPACKED_PITCH_EG_LEVEL_4] = s[E++], r[t.UNPACKED_ALGORITHM] = s[E++], r[t.UNPACKED_FEEDBACK] = s[E++], r[t.UNPACKED_OSC_SYNC] = s[E++], r[t.UNPACKED_LFO_SPEED] = s[E++], r[t.UNPACKED_LFO_DELAY] = s[E++], r[t.UNPACKED_LFO_PM_DEPTH] = s[E++], r[t.UNPACKED_LFO_AM_DEPTH] = s[E++], r[t.UNPACKED_LFO_KEY_SYNC] = s[E++], r[t.UNPACKED_LFO_WAVE] = s[E++], r[t.UNPACKED_LFO_PM_SENS] = s[E++], r[t.UNPACKED_TRANSPOSE] = s[E++];
+      for (let l = 0; l < t.NAME_LENGTH; l++)
+        r[t.UNPACKED_NAME_START + l] = s[E++];
+      const o = t.pack(r);
+      return new t(o, i);
     }
-    return new n(e, s);
+    return new t(s, i);
   }
   /**
    * Create a DX7Voice from a JSON object
@@ -3087,27 +2906,27 @@ class n {
    * @returns {DX7Voice}
    * @throws {DX7ValidationError} If JSON structure is invalid
    */
-  static fromJSON(t, s = 0) {
-    if (!t || typeof t != "object")
-      throw new c("Invalid JSON: expected object", "json", t);
-    const E = new Uint8Array(n.UNPACKED_SIZE), e = (a, o, h, N = 0, d = 127) => {
-      if (o == null)
-        throw new c(`Missing required parameter: ${h}`, h, o);
-      const T = Number(o);
+  static fromJSON(e, i = 0) {
+    if (!e || typeof e != "object")
+      throw new O("Invalid JSON: expected object", "json", e);
+    const n = new Uint8Array(t.UNPACKED_SIZE), s = (a, A, h, N = 0, d = 127) => {
+      if (A == null)
+        throw new O(`Missing required parameter: ${h}`, h, A);
+      const T = Number(A);
       if (Number.isNaN(T))
-        throw new c(`Invalid parameter value for ${h}: ${o}`, h, o);
+        throw new O(`Invalid parameter value for ${h}: ${A}`, h, A);
       if (T < N || T > d)
-        throw new c(
+        throw new O(
           `Parameter ${h} out of range: ${T} (must be ${N}-${d})`,
           h,
           T
         );
-      E[a] = Math.floor(T);
-    }, _ = (a) => {
-      const o = { "-LN": 0, "-EX": 1, "+EX": 2, "+LN": 3 };
-      return o[a] !== void 0 ? o[a] : 0;
-    }, i = (a) => {
-      const o = {
+      n[a] = Math.floor(T);
+    }, r = (a) => {
+      const A = { "-LN": 0, "-EX": 1, "+EX": 2, "+LN": 3 };
+      return A[a] !== void 0 ? A[a] : 0;
+    }, E = (a) => {
+      const A = {
         TRIANGLE: 0,
         "SAW DOWN": 1,
         "SAW UP": 2,
@@ -3115,113 +2934,113 @@ class n {
         SINE: 4,
         "SAMPLE & HOLD": 5
       };
-      return o[a] !== void 0 ? o[a] : 0;
-    }, r = (a) => {
+      return A[a] !== void 0 ? A[a] : 0;
+    }, o = (a) => {
       if (!a || typeof a != "string") return 60;
-      const o = a.trim().match(/^([A-G]#?)(-?\d+)$/);
-      if (!o) return 60;
-      const [, h, N] = o, d = parseInt(N, 10), f = { C: 0, "C#": 1, D: 2, "D#": 3, E: 4, F: 5, "F#": 6, G: 7, "G#": 8, A: 9, "A#": 10, B: 11 }[h.toUpperCase()];
-      return f === void 0 ? 60 : (d - n.MIDI_OCTAVE_OFFSET) * 12 + f;
+      const A = a.trim().match(/^([A-G]#?)(-?\d+)$/);
+      if (!A) return 60;
+      const [, h, N] = A, d = parseInt(N, 10), f = { C: 0, "C#": 1, D: 2, "D#": 3, E: 4, F: 5, "F#": 6, G: 7, "G#": 8, A: 9, "A#": 10, B: 11 }[h.toUpperCase()];
+      return f === void 0 ? 60 : (d - t.MIDI_OCTAVE_OFFSET) * 12 + f;
     };
-    if (!Array.isArray(t.operators))
-      throw new c("Invalid operators array: expected array", "operators", t.operators);
-    for (let a = 0; a < t.operators.length; a++) {
-      const o = t.operators[a];
-      if (!o || typeof o != "object")
-        throw new c(`Invalid operator data at index ${a}`, `operators[${a}]`, o);
-      if (!o.eg || !Array.isArray(o.eg.rates) || o.eg.rates.length !== 4)
-        throw new c(
+    if (!Array.isArray(e.operators))
+      throw new O("Invalid operators array: expected array", "operators", e.operators);
+    for (let a = 0; a < e.operators.length; a++) {
+      const A = e.operators[a];
+      if (!A || typeof A != "object")
+        throw new O(`Invalid operator data at index ${a}`, `operators[${a}]`, A);
+      if (!A.eg || !Array.isArray(A.eg.rates) || A.eg.rates.length !== 4)
+        throw new O(
           `Invalid EG rates for operator ${a}`,
           `operators[${a}].eg.rates`,
-          o.eg?.rates
+          A.eg?.rates
         );
-      if (!o.eg || !Array.isArray(o.eg.levels) || o.eg.levels.length !== 4)
-        throw new c(
+      if (!A.eg || !Array.isArray(A.eg.levels) || A.eg.levels.length !== 4)
+        throw new O(
           `Invalid EG levels for operator ${a}`,
           `operators[${a}].eg.levels`,
-          o.eg?.levels
+          A.eg?.levels
         );
     }
-    if (t.operators.length !== n.NUM_OPERATORS)
-      throw new c(
-        `Invalid operators array: expected ${n.NUM_OPERATORS} operators`,
+    if (e.operators.length !== t.NUM_OPERATORS)
+      throw new O(
+        `Invalid operators array: expected ${t.NUM_OPERATORS} operators`,
         "operators",
-        t.operators
+        e.operators
       );
-    for (let a = 0; a < n.NUM_OPERATORS; a++) {
-      const o = t.operators[a], h = a * n.UNPACKED_OP_SIZE;
-      if (!o.eg || !Array.isArray(o.eg.rates) || o.eg.rates.length !== 4)
-        throw new c(
+    for (let a = 0; a < t.NUM_OPERATORS; a++) {
+      const A = e.operators[a], h = a * t.UNPACKED_OP_SIZE;
+      if (!A.eg || !Array.isArray(A.eg.rates) || A.eg.rates.length !== 4)
+        throw new O(
           `Invalid EG rates for operator ${a}`,
           `operators[${a}].eg.rates`,
-          o.eg?.rates
+          A.eg?.rates
         );
-      if (e(h + n.UNPACKED_OP_EG_RATE_1, o.eg.rates[0], `operators[${a}].eg.rates[0]`, 0, 99), e(h + n.UNPACKED_OP_EG_RATE_2, o.eg.rates[1], `operators[${a}].eg.rates[1]`, 0, 99), e(h + n.UNPACKED_OP_EG_RATE_3, o.eg.rates[2], `operators[${a}].eg.rates[2]`, 0, 99), e(h + n.UNPACKED_OP_EG_RATE_4, o.eg.rates[3], `operators[${a}].eg.rates[3]`, 0, 99), !o.eg || !Array.isArray(o.eg.levels) || o.eg.levels.length !== 4)
-        throw new c(
+      if (s(h + t.UNPACKED_OP_EG_RATE_1, A.eg.rates[0], `operators[${a}].eg.rates[0]`, 0, 99), s(h + t.UNPACKED_OP_EG_RATE_2, A.eg.rates[1], `operators[${a}].eg.rates[1]`, 0, 99), s(h + t.UNPACKED_OP_EG_RATE_3, A.eg.rates[2], `operators[${a}].eg.rates[2]`, 0, 99), s(h + t.UNPACKED_OP_EG_RATE_4, A.eg.rates[3], `operators[${a}].eg.rates[3]`, 0, 99), !A.eg || !Array.isArray(A.eg.levels) || A.eg.levels.length !== 4)
+        throw new O(
           `Invalid EG levels for operator ${a}`,
           `operators[${a}].eg.levels`,
-          o.eg?.levels
+          A.eg?.levels
         );
-      e(h + n.UNPACKED_OP_EG_LEVEL_1, o.eg.levels[0], `operators[${a}].eg.levels[0]`, 0, 99), e(h + n.UNPACKED_OP_EG_LEVEL_2, o.eg.levels[1], `operators[${a}].eg.levels[1]`, 0, 99), e(h + n.UNPACKED_OP_EG_LEVEL_3, o.eg.levels[2], `operators[${a}].eg.levels[2]`, 0, 99), e(h + n.UNPACKED_OP_EG_LEVEL_4, o.eg.levels[3], `operators[${a}].eg.levels[3]`, 0, 99);
-      const N = r(o.key?.breakPoint) - n.MIDI_BREAK_POINT_OFFSET;
-      e(h + n.UNPACKED_OP_BREAK_POINT, N, `operators[${a}].key.breakPoint`, 0, 127), e(
-        h + n.UNPACKED_OP_L_SCALE_DEPTH,
-        o.scale?.left?.depth || 0,
+      s(h + t.UNPACKED_OP_EG_LEVEL_1, A.eg.levels[0], `operators[${a}].eg.levels[0]`, 0, 99), s(h + t.UNPACKED_OP_EG_LEVEL_2, A.eg.levels[1], `operators[${a}].eg.levels[1]`, 0, 99), s(h + t.UNPACKED_OP_EG_LEVEL_3, A.eg.levels[2], `operators[${a}].eg.levels[2]`, 0, 99), s(h + t.UNPACKED_OP_EG_LEVEL_4, A.eg.levels[3], `operators[${a}].eg.levels[3]`, 0, 99);
+      const N = o(A.key?.breakPoint) - t.MIDI_BREAK_POINT_OFFSET;
+      s(h + t.UNPACKED_OP_BREAK_POINT, N, `operators[${a}].key.breakPoint`, 0, 127), s(
+        h + t.UNPACKED_OP_L_SCALE_DEPTH,
+        A.scale?.left?.depth || 0,
         `operators[${a}].scale.left.depth`,
         0,
         99
-      ), e(
-        h + n.UNPACKED_OP_R_SCALE_DEPTH,
-        o.scale?.right?.depth || 0,
+      ), s(
+        h + t.UNPACKED_OP_R_SCALE_DEPTH,
+        A.scale?.right?.depth || 0,
         `operators[${a}].scale.right.depth`,
         0,
         99
-      ), E[h + n.UNPACKED_OP_L_CURVE] = _(o.scale?.left?.curve || "-LN"), E[h + n.UNPACKED_OP_R_CURVE] = _(o.scale?.right?.curve || "-LN"), e(
-        h + n.UNPACKED_OP_RATE_SCALING,
-        o.key?.scaling || 0,
+      ), n[h + t.UNPACKED_OP_L_CURVE] = r(A.scale?.left?.curve || "-LN"), n[h + t.UNPACKED_OP_R_CURVE] = r(A.scale?.right?.curve || "-LN"), s(
+        h + t.UNPACKED_OP_RATE_SCALING,
+        A.key?.scaling || 0,
         `operators[${a}].key.scaling`,
         0,
         7
       );
-      const d = Number(o.osc?.detune) || 0;
-      e(h + n.UNPACKED_OP_DETUNE, d + 7, `operators[${a}].osc.detune`, 0, 14), e(
-        h + n.UNPACKED_OP_AMP_MOD_SENS,
-        o.output?.ampModSens || 0,
+      const d = Number(A.osc?.detune) || 0;
+      s(h + t.UNPACKED_OP_DETUNE, d + 7, `operators[${a}].osc.detune`, 0, 14), s(
+        h + t.UNPACKED_OP_AMP_MOD_SENS,
+        A.output?.ampModSens || 0,
         `operators[${a}].output.ampModSens`,
         0,
         3
-      ), e(
-        h + n.UNPACKED_OP_OUTPUT_LEVEL,
-        o.output?.level || 0,
+      ), s(
+        h + t.UNPACKED_OP_OUTPUT_LEVEL,
+        A.output?.level || 0,
         `operators[${a}].output.level`,
         0,
         99
       );
-      const T = o.osc?.freq?.mode?.toUpperCase() === "FIXED" ? 1 : 0, f = Number(o.osc?.freq?.coarse) || 0, I = Number(o.osc?.freq?.fine) || 0;
-      E[h + n.UNPACKED_OP_MODE] = T, e(h + n.UNPACKED_OP_FREQ_COARSE, f, `operators[${a}].osc.freq.coarse`, 0, 31), e(h + n.UNPACKED_OP_FREQ_FINE, I, `operators[${a}].osc.freq.fine`, 0, 15), e(
-        h + n.UNPACKED_OP_KEY_VEL_SENS,
-        o.key?.velocity || 0,
+      const T = A.osc?.freq?.mode?.toUpperCase() === "FIXED" ? 1 : 0, f = Number(A.osc?.freq?.coarse) || 0, I = Number(A.osc?.freq?.fine) || 0;
+      n[h + t.UNPACKED_OP_MODE] = T, s(h + t.UNPACKED_OP_FREQ_COARSE, f, `operators[${a}].osc.freq.coarse`, 0, 31), s(h + t.UNPACKED_OP_FREQ_FINE, I, `operators[${a}].osc.freq.fine`, 0, 15), s(
+        h + t.UNPACKED_OP_KEY_VEL_SENS,
+        A.key?.velocity || 0,
         `operators[${a}].key.velocity`,
         0,
         7
       );
     }
-    if (!t.pitchEG || !Array.isArray(t.pitchEG.rates) || t.pitchEG.rates.length !== 4)
-      throw new c("Invalid pitch EG rates", "pitchEG.rates", t.pitchEG?.rates);
-    if (!t.pitchEG || !Array.isArray(t.pitchEG.levels) || t.pitchEG.levels.length !== 4)
-      throw new c("Invalid pitch EG levels", "pitchEG.levels", t.pitchEG?.levels);
-    if (e(n.UNPACKED_PITCH_EG_RATE_1, t.pitchEG.rates[0], "pitchEG.rates[0]", 0, 99), e(n.UNPACKED_PITCH_EG_RATE_2, t.pitchEG.rates[1], "pitchEG.rates[1]", 0, 99), e(n.UNPACKED_PITCH_EG_RATE_3, t.pitchEG.rates[2], "pitchEG.rates[2]", 0, 99), e(n.UNPACKED_PITCH_EG_RATE_4, t.pitchEG.rates[3], "pitchEG.rates[3]", 0, 99), e(n.UNPACKED_PITCH_EG_LEVEL_1, t.pitchEG.levels[0], "pitchEG.levels[0]", 0, 99), e(n.UNPACKED_PITCH_EG_LEVEL_2, t.pitchEG.levels[1], "pitchEG.levels[1]", 0, 99), e(n.UNPACKED_PITCH_EG_LEVEL_3, t.pitchEG.levels[2], "pitchEG.levels[2]", 0, 99), e(n.UNPACKED_PITCH_EG_LEVEL_4, t.pitchEG.levels[3], "pitchEG.levels[3]", 0, 99), !t.lfo || typeof t.lfo != "object")
-      throw new c("Invalid LFO data", "lfo", t.lfo);
-    if (e(n.UNPACKED_LFO_SPEED, t.lfo.speed, "lfo.speed", 0, 99), e(n.UNPACKED_LFO_DELAY, t.lfo.delay, "lfo.delay", 0, 99), e(n.UNPACKED_LFO_PM_DEPTH, t.lfo.pmDepth, "lfo.pmDepth", 0, 99), e(n.UNPACKED_LFO_AM_DEPTH, t.lfo.amDepth, "lfo.amDepth", 0, 99), E[n.UNPACKED_LFO_KEY_SYNC] = t.lfo.keySync ? 1 : 0, E[n.UNPACKED_LFO_WAVE] = i(t.lfo.wave), !t.global || typeof t.global != "object")
-      throw new c("Invalid global data", "global", t.global);
-    const u = Number(t.global.algorithm) || 1;
-    e(n.UNPACKED_ALGORITHM, u - 1, "global.algorithm", 0, 31), e(n.UNPACKED_FEEDBACK, t.global.feedback, "global.feedback", 0, 7), E[n.UNPACKED_OSC_SYNC] = t.global.oscKeySync ? 1 : 0, e(n.UNPACKED_LFO_PM_SENS, t.global.pitchModSens, "global.pitchModSens", 0, 7);
-    const S = Number(t.global.transpose) || 0;
-    e(n.UNPACKED_TRANSPOSE, S + n.TRANSPOSE_CENTER, "global.transpose", 0, 127), e(n.UNPACKED_AMP_MOD_SENS, t.global.ampModSens || 0, "global.ampModSens", 0, 3), e(n.UNPACKED_EG_BIAS_SENS, t.global.egBiasSens || 0, "global.egBiasSens", 0, 7);
-    const P = t.name || "";
-    for (let a = 0; a < n.NAME_LENGTH; a++)
-      E[n.UNPACKED_NAME_START + a] = a < P.length ? P.charCodeAt(a) : n.CHAR_SPACE;
-    return n.fromUnpacked(E, s);
+    if (!e.pitchEG || !Array.isArray(e.pitchEG.rates) || e.pitchEG.rates.length !== 4)
+      throw new O("Invalid pitch EG rates", "pitchEG.rates", e.pitchEG?.rates);
+    if (!e.pitchEG || !Array.isArray(e.pitchEG.levels) || e.pitchEG.levels.length !== 4)
+      throw new O("Invalid pitch EG levels", "pitchEG.levels", e.pitchEG?.levels);
+    if (s(t.UNPACKED_PITCH_EG_RATE_1, e.pitchEG.rates[0], "pitchEG.rates[0]", 0, 99), s(t.UNPACKED_PITCH_EG_RATE_2, e.pitchEG.rates[1], "pitchEG.rates[1]", 0, 99), s(t.UNPACKED_PITCH_EG_RATE_3, e.pitchEG.rates[2], "pitchEG.rates[2]", 0, 99), s(t.UNPACKED_PITCH_EG_RATE_4, e.pitchEG.rates[3], "pitchEG.rates[3]", 0, 99), s(t.UNPACKED_PITCH_EG_LEVEL_1, e.pitchEG.levels[0], "pitchEG.levels[0]", 0, 99), s(t.UNPACKED_PITCH_EG_LEVEL_2, e.pitchEG.levels[1], "pitchEG.levels[1]", 0, 99), s(t.UNPACKED_PITCH_EG_LEVEL_3, e.pitchEG.levels[2], "pitchEG.levels[2]", 0, 99), s(t.UNPACKED_PITCH_EG_LEVEL_4, e.pitchEG.levels[3], "pitchEG.levels[3]", 0, 99), !e.lfo || typeof e.lfo != "object")
+      throw new O("Invalid LFO data", "lfo", e.lfo);
+    if (s(t.UNPACKED_LFO_SPEED, e.lfo.speed, "lfo.speed", 0, 99), s(t.UNPACKED_LFO_DELAY, e.lfo.delay, "lfo.delay", 0, 99), s(t.UNPACKED_LFO_PM_DEPTH, e.lfo.pmDepth, "lfo.pmDepth", 0, 99), s(t.UNPACKED_LFO_AM_DEPTH, e.lfo.amDepth, "lfo.amDepth", 0, 99), n[t.UNPACKED_LFO_KEY_SYNC] = e.lfo.keySync ? 1 : 0, n[t.UNPACKED_LFO_WAVE] = E(e.lfo.wave), !e.global || typeof e.global != "object")
+      throw new O("Invalid global data", "global", e.global);
+    const l = Number(e.global.algorithm) || 1;
+    s(t.UNPACKED_ALGORITHM, l - 1, "global.algorithm", 0, 31), s(t.UNPACKED_FEEDBACK, e.global.feedback, "global.feedback", 0, 7), n[t.UNPACKED_OSC_SYNC] = e.global.oscKeySync ? 1 : 0, s(t.UNPACKED_LFO_PM_SENS, e.global.pitchModSens, "global.pitchModSens", 0, 7);
+    const S = Number(e.global.transpose) || 0;
+    s(t.UNPACKED_TRANSPOSE, S + t.TRANSPOSE_CENTER, "global.transpose", 0, 127), s(t.UNPACKED_AMP_MOD_SENS, e.global.ampModSens || 0, "global.ampModSens", 0, 3), s(t.UNPACKED_EG_BIAS_SENS, e.global.egBiasSens || 0, "global.egBiasSens", 0, 7);
+    const u = e.name || "";
+    for (let a = 0; a < t.NAME_LENGTH; a++)
+      n[t.UNPACKED_NAME_START + a] = a < u.length ? u.charCodeAt(a) : t.CHAR_SPACE;
+    return t.fromUnpacked(n, i);
   }
   /**
    * Export voice to DX7 single voice SysEx format (VCED format)
@@ -3230,146 +3049,178 @@ class n {
    * @returns {Uint8Array} Single voice SysEx data (163 bytes)
    */
   toSysEx() {
-    const t = this.unpack(), s = new Uint8Array(n.VCED_SIZE);
-    let E = 0;
-    s[E++] = n.VCED_SYSEX_START, s[E++] = n.VCED_YAMAHA_ID, s[E++] = n.VCED_SUB_STATUS, s[E++] = n.VCED_FORMAT_SINGLE, s[E++] = n.VCED_BYTE_COUNT_MSB, s[E++] = n.VCED_BYTE_COUNT_LSB;
-    for (let _ = n.NUM_OPERATORS - 1; _ >= 0; _--) {
-      const i = _ * n.UNPACKED_OP_SIZE;
-      s[E++] = t[i + n.UNPACKED_OP_EG_RATE_1], s[E++] = t[i + n.UNPACKED_OP_EG_RATE_2], s[E++] = t[i + n.UNPACKED_OP_EG_RATE_3], s[E++] = t[i + n.UNPACKED_OP_EG_RATE_4], s[E++] = t[i + n.UNPACKED_OP_EG_LEVEL_1], s[E++] = t[i + n.UNPACKED_OP_EG_LEVEL_2], s[E++] = t[i + n.UNPACKED_OP_EG_LEVEL_3], s[E++] = t[i + n.UNPACKED_OP_EG_LEVEL_4], s[E++] = t[i + n.UNPACKED_OP_BREAK_POINT], s[E++] = t[i + n.UNPACKED_OP_L_SCALE_DEPTH], s[E++] = t[i + n.UNPACKED_OP_R_SCALE_DEPTH], s[E++] = t[i + n.UNPACKED_OP_L_CURVE], s[E++] = t[i + n.UNPACKED_OP_R_CURVE], s[E++] = t[i + n.UNPACKED_OP_RATE_SCALING], s[E++] = t[i + n.UNPACKED_OP_DETUNE];
-      const r = t[i + n.UNPACKED_OP_AMP_MOD_SENS] & n.MASK_2BIT, u = t[i + n.UNPACKED_OP_KEY_VEL_SENS] & n.MASK_3BIT;
-      s[E++] = r | u << 2, s[E++] = t[i + n.UNPACKED_OP_OUTPUT_LEVEL], s[E++] = t[i + n.UNPACKED_OP_MODE], s[E++] = t[i + n.UNPACKED_OP_FREQ_COARSE], s[E++] = t[i + n.UNPACKED_OP_OSC_DETUNE], s[E++] = t[i + n.UNPACKED_OP_FREQ_FINE];
-    }
-    s[E++] = t[n.UNPACKED_PITCH_EG_RATE_1], s[E++] = t[n.UNPACKED_PITCH_EG_RATE_2], s[E++] = t[n.UNPACKED_PITCH_EG_RATE_3], s[E++] = t[n.UNPACKED_PITCH_EG_RATE_4], s[E++] = t[n.UNPACKED_PITCH_EG_LEVEL_1], s[E++] = t[n.UNPACKED_PITCH_EG_LEVEL_2], s[E++] = t[n.UNPACKED_PITCH_EG_LEVEL_3], s[E++] = t[n.UNPACKED_PITCH_EG_LEVEL_4], s[E++] = t[n.UNPACKED_ALGORITHM], s[E++] = t[n.UNPACKED_FEEDBACK], s[E++] = t[n.UNPACKED_OSC_SYNC], s[E++] = t[n.UNPACKED_LFO_SPEED], s[E++] = t[n.UNPACKED_LFO_DELAY], s[E++] = t[n.UNPACKED_LFO_PM_DEPTH], s[E++] = t[n.UNPACKED_LFO_AM_DEPTH], s[E++] = t[n.UNPACKED_LFO_KEY_SYNC], s[E++] = t[n.UNPACKED_LFO_WAVE], s[E++] = t[n.UNPACKED_LFO_PM_SENS], s[E++] = t[n.UNPACKED_TRANSPOSE];
-    for (let _ = 0; _ < n.NAME_LENGTH; _++)
-      s[E++] = t[n.UNPACKED_NAME_START + _];
-    const e = s.subarray(
-      n.VCED_HEADER_SIZE,
-      n.VCED_HEADER_SIZE + n.VCED_DATA_SIZE
+    const e = this.unpack(), i = new Uint8Array(t.VCED_SIZE);
+    let n = 0;
+    i[n++] = t.VCED_SYSEX_START, i[n++] = t.VCED_YAMAHA_ID, i[n++] = t.VCED_SUB_STATUS, i[n++] = t.VCED_FORMAT_SINGLE, i[n++] = t.VCED_BYTE_COUNT_MSB, i[n++] = t.VCED_BYTE_COUNT_LSB;
+    for (let r = t.NUM_OPERATORS - 1; r >= 0; r--) {
+      const E = r * t.UNPACKED_OP_SIZE;
+      i[n++] = e[E + t.UNPACKED_OP_EG_RATE_1], i[n++] = e[E + t.UNPACKED_OP_EG_RATE_2], i[n++] = e[E + t.UNPACKED_OP_EG_RATE_3], i[n++] = e[E + t.UNPACKED_OP_EG_RATE_4], i[n++] = e[E + t.UNPACKED_OP_EG_LEVEL_1], i[n++] = e[E + t.UNPACKED_OP_EG_LEVEL_2], i[n++] = e[E + t.UNPACKED_OP_EG_LEVEL_3], i[n++] = e[E + t.UNPACKED_OP_EG_LEVEL_4], i[n++] = e[E + t.UNPACKED_OP_BREAK_POINT], i[n++] = e[E + t.UNPACKED_OP_L_SCALE_DEPTH], i[n++] = e[E + t.UNPACKED_OP_R_SCALE_DEPTH], i[n++] = e[E + t.UNPACKED_OP_L_CURVE], i[n++] = e[E + t.UNPACKED_OP_R_CURVE], i[n++] = e[E + t.UNPACKED_OP_RATE_SCALING], i[n++] = e[E + t.UNPACKED_OP_DETUNE];
+      const o = e[E + t.UNPACKED_OP_AMP_MOD_SENS] & t.MASK_2BIT, l = e[E + t.UNPACKED_OP_KEY_VEL_SENS] & t.MASK_3BIT;
+      i[n++] = o | l << 2, i[n++] = e[E + t.UNPACKED_OP_OUTPUT_LEVEL], i[n++] = e[E + t.UNPACKED_OP_MODE], i[n++] = e[E + t.UNPACKED_OP_FREQ_COARSE], i[n++] = e[E + t.UNPACKED_OP_OSC_DETUNE], i[n++] = e[E + t.UNPACKED_OP_FREQ_FINE];
+    }
+    i[n++] = e[t.UNPACKED_PITCH_EG_RATE_1], i[n++] = e[t.UNPACKED_PITCH_EG_RATE_2], i[n++] = e[t.UNPACKED_PITCH_EG_RATE_3], i[n++] = e[t.UNPACKED_PITCH_EG_RATE_4], i[n++] = e[t.UNPACKED_PITCH_EG_LEVEL_1], i[n++] = e[t.UNPACKED_PITCH_EG_LEVEL_2], i[n++] = e[t.UNPACKED_PITCH_EG_LEVEL_3], i[n++] = e[t.UNPACKED_PITCH_EG_LEVEL_4], i[n++] = e[t.UNPACKED_ALGORITHM], i[n++] = e[t.UNPACKED_FEEDBACK], i[n++] = e[t.UNPACKED_OSC_SYNC], i[n++] = e[t.UNPACKED_LFO_SPEED], i[n++] = e[t.UNPACKED_LFO_DELAY], i[n++] = e[t.UNPACKED_LFO_PM_DEPTH], i[n++] = e[t.UNPACKED_LFO_AM_DEPTH], i[n++] = e[t.UNPACKED_LFO_KEY_SYNC], i[n++] = e[t.UNPACKED_LFO_WAVE], i[n++] = e[t.UNPACKED_LFO_PM_SENS], i[n++] = e[t.UNPACKED_TRANSPOSE];
+    for (let r = 0; r < t.NAME_LENGTH; r++)
+      i[n++] = e[t.UNPACKED_NAME_START + r];
+    const s = i.subarray(
+      t.VCED_HEADER_SIZE,
+      t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE
     );
-    return s[E++] = l._calculateChecksum(e, n.VCED_DATA_SIZE), s[E++] = n.VCED_SYSEX_END, s;
+    return i[n++] = M._calculateChecksum(s, t.VCED_DATA_SIZE), i[n++] = t.VCED_SYSEX_END, i;
   }
   /**
    * Convert voice to JSON format
    * @returns {object} Voice data in JSON format
    */
   toJSON() {
-    const t = this.unpack(), s = [], E = (i) => ["-LN", "-EX", "+EX", "+LN"][i] || "UNKNOWN", e = (i) => ["TRIANGLE", "SAW DOWN", "SAW UP", "SQUARE", "SINE", "SAMPLE & HOLD"][i] || "UNKNOWN", _ = (i) => {
-      const r = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], u = Math.floor(i / 12) + n.MIDI_OCTAVE_OFFSET;
-      return `${r[i % 12]}${u}`;
+    const e = this.unpack(), i = [], n = (E) => ["-LN", "-EX", "+EX", "+LN"][E] || "UNKNOWN", s = (E) => ["TRIANGLE", "SAW DOWN", "SAW UP", "SQUARE", "SINE", "SAMPLE & HOLD"][E] || "UNKNOWN", r = (E) => {
+      const o = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], l = Math.floor(E / 12) + t.MIDI_OCTAVE_OFFSET;
+      return `${o[E % 12]}${l}`;
     };
-    for (let i = 0; i < n.NUM_OPERATORS; i++) {
-      const r = i * n.UNPACKED_OP_SIZE, u = t[r + n.UNPACKED_OP_MODE] === 0 ? "RATIO" : "FIXED";
-      s.push({
-        id: i + 1,
+    for (let E = 0; E < t.NUM_OPERATORS; E++) {
+      const o = E * t.UNPACKED_OP_SIZE, l = e[o + t.UNPACKED_OP_MODE] === 0 ? "RATIO" : "FIXED";
+      i.push({
+        id: E + 1,
         osc: {
-          detune: t[r + n.UNPACKED_OP_OSC_DETUNE],
+          detune: e[o + t.UNPACKED_OP_OSC_DETUNE],
           freq: {
-            coarse: t[r + n.UNPACKED_OP_FREQ_COARSE],
-            fine: t[r + n.UNPACKED_OP_FREQ_FINE],
-            mode: u
+            coarse: e[o + t.UNPACKED_OP_FREQ_COARSE],
+            fine: e[o + t.UNPACKED_OP_FREQ_FINE],
+            mode: l
           }
         },
         eg: {
           rates: [
-            t[r + n.UNPACKED_OP_EG_RATE_1],
-            t[r + n.UNPACKED_OP_EG_RATE_2],
-            t[r + n.UNPACKED_OP_EG_RATE_3],
-            t[r + n.UNPACKED_OP_EG_RATE_4]
+            e[o + t.UNPACKED_OP_EG_RATE_1],
+            e[o + t.UNPACKED_OP_EG_RATE_2],
+            e[o + t.UNPACKED_OP_EG_RATE_3],
+            e[o + t.UNPACKED_OP_EG_RATE_4]
           ],
           levels: [
-            t[r + n.UNPACKED_OP_EG_LEVEL_1],
-            t[r + n.UNPACKED_OP_EG_LEVEL_2],
-            t[r + n.UNPACKED_OP_EG_LEVEL_3],
-            t[r + n.UNPACKED_OP_EG_LEVEL_4]
+            e[o + t.UNPACKED_OP_EG_LEVEL_1],
+            e[o + t.UNPACKED_OP_EG_LEVEL_2],
+            e[o + t.UNPACKED_OP_EG_LEVEL_3],
+            e[o + t.UNPACKED_OP_EG_LEVEL_4]
           ]
         },
         key: {
-          velocity: t[r + n.UNPACKED_OP_KEY_VEL_SENS],
-          scaling: t[r + n.UNPACKED_OP_RATE_SCALING],
-          breakPoint: _(
-            t[r + n.UNPACKED_OP_BREAK_POINT] + n.MIDI_BREAK_POINT_OFFSET
+          velocity: e[o + t.UNPACKED_OP_KEY_VEL_SENS],
+          scaling: e[o + t.UNPACKED_OP_RATE_SCALING],
+          breakPoint: r(
+            e[o + t.UNPACKED_OP_BREAK_POINT] + t.MIDI_BREAK_POINT_OFFSET
           )
         },
         output: {
-          level: t[r + n.UNPACKED_OP_OUTPUT_LEVEL],
-          ampModSens: t[r + n.UNPACKED_OP_AMP_MOD_SENS]
+          level: e[o + t.UNPACKED_OP_OUTPUT_LEVEL],
+          ampModSens: e[o + t.UNPACKED_OP_AMP_MOD_SENS]
         },
         scale: {
           left: {
-            depth: t[r + n.UNPACKED_OP_L_SCALE_DEPTH],
-            curve: E(t[r + n.UNPACKED_OP_L_CURVE])
+            depth: e[o + t.UNPACKED_OP_L_SCALE_DEPTH],
+            curve: n(e[o + t.UNPACKED_OP_L_CURVE])
           },
           right: {
-            depth: t[r + n.UNPACKED_OP_R_SCALE_DEPTH],
-            curve: E(t[r + n.UNPACKED_OP_R_CURVE])
+            depth: e[o + t.UNPACKED_OP_R_SCALE_DEPTH],
+            curve: n(e[o + t.UNPACKED_OP_R_CURVE])
           }
         }
       });
     }
     return {
       name: this.name || "(Empty)",
-      operators: s,
+      operators: i,
       pitchEG: {
         rates: [
-          t[n.UNPACKED_PITCH_EG_RATE_1],
-          t[n.UNPACKED_PITCH_EG_RATE_2],
-          t[n.UNPACKED_PITCH_EG_RATE_3],
-          t[n.UNPACKED_PITCH_EG_RATE_4]
+          e[t.UNPACKED_PITCH_EG_RATE_1],
+          e[t.UNPACKED_PITCH_EG_RATE_2],
+          e[t.UNPACKED_PITCH_EG_RATE_3],
+          e[t.UNPACKED_PITCH_EG_RATE_4]
         ],
         levels: [
-          t[n.UNPACKED_PITCH_EG_LEVEL_1],
-          t[n.UNPACKED_PITCH_EG_LEVEL_2],
-          t[n.UNPACKED_PITCH_EG_LEVEL_3],
-          t[n.UNPACKED_PITCH_EG_LEVEL_4]
+          e[t.UNPACKED_PITCH_EG_LEVEL_1],
+          e[t.UNPACKED_PITCH_EG_LEVEL_2],
+          e[t.UNPACKED_PITCH_EG_LEVEL_3],
+          e[t.UNPACKED_PITCH_EG_LEVEL_4]
         ]
       },
       lfo: {
-        speed: t[n.UNPACKED_LFO_SPEED],
-        delay: t[n.UNPACKED_LFO_DELAY],
-        pmDepth: t[n.UNPACKED_LFO_PM_DEPTH],
-        amDepth: t[n.UNPACKED_LFO_AM_DEPTH],
-        keySync: t[n.UNPACKED_LFO_KEY_SYNC] === 1,
-        wave: e(t[n.UNPACKED_LFO_WAVE])
+        speed: e[t.UNPACKED_LFO_SPEED],
+        delay: e[t.UNPACKED_LFO_DELAY],
+        pmDepth: e[t.UNPACKED_LFO_PM_DEPTH],
+        amDepth: e[t.UNPACKED_LFO_AM_DEPTH],
+        keySync: e[t.UNPACKED_LFO_KEY_SYNC] === 1,
+        wave: s(e[t.UNPACKED_LFO_WAVE])
       },
       global: {
-        algorithm: t[n.UNPACKED_ALGORITHM] + 1,
-        feedback: t[n.UNPACKED_FEEDBACK],
-        oscKeySync: t[n.UNPACKED_OSC_SYNC] === 1,
-        pitchModSens: t[n.UNPACKED_LFO_PM_SENS],
-        transpose: t[n.UNPACKED_TRANSPOSE] - n.TRANSPOSE_CENTER
+        algorithm: e[t.UNPACKED_ALGORITHM] + 1,
+        feedback: e[t.UNPACKED_FEEDBACK],
+        oscKeySync: e[t.UNPACKED_OSC_SYNC] === 1,
+        pitchModSens: e[t.UNPACKED_LFO_PM_SENS],
+        transpose: e[t.UNPACKED_TRANSPOSE] - t.TRANSPOSE_CENTER
       }
     };
   }
-}
-class l {
-  // SysEx header
-  static SYSEX_START = 240;
-  static SYSEX_END = 247;
-  static SYSEX_YAMAHA_ID = 67;
-  static SYSEX_SUB_STATUS = 0;
-  static SYSEX_FORMAT_32_VOICES = 9;
-  static SYSEX_BYTE_COUNT_MSB = 32;
-  static SYSEX_BYTE_COUNT_LSB = 0;
-  static SYSEX_HEADER = [
-    l.SYSEX_START,
-    l.SYSEX_YAMAHA_ID,
-    l.SYSEX_SUB_STATUS,
-    l.SYSEX_FORMAT_32_VOICES,
-    l.SYSEX_BYTE_COUNT_MSB,
-    l.SYSEX_BYTE_COUNT_LSB
-  ];
-  static SYSEX_HEADER_SIZE = 6;
-  // Bank structure
-  static VOICE_DATA_SIZE = 4096;
-  // 32 voices × 128 bytes
-  static SYSEX_SIZE = 4104;
-  // Header(6) + Data(4096) + Checksum(1) + End(1)
-  static VOICE_SIZE = 128;
-  // Bytes per voice in packed format
-  static NUM_VOICES = 32;
-  // Checksum
-  static CHECKSUM_MODULO = 128;
-  static MASK_7BIT = 127;
+};
+// Packed format (128 bytes)
+// See: DX7 Service Manual, Voice Memory Format
+_(t, "PACKED_SIZE", 128), _(t, "PACKED_OP_SIZE", 17), // 17 bytes per operator in packed format
+_(t, "NUM_OPERATORS", 6), // Packed operator parameter offsets (within each 17-byte operator block)
+_(t, "PACKED_OP_EG_RATE_1", 0), _(t, "PACKED_OP_EG_RATE_2", 1), _(t, "PACKED_OP_EG_RATE_3", 2), _(t, "PACKED_OP_EG_RATE_4", 3), _(t, "PACKED_OP_EG_LEVEL_1", 4), _(t, "PACKED_OP_EG_LEVEL_2", 5), _(t, "PACKED_OP_EG_LEVEL_3", 6), _(t, "PACKED_OP_EG_LEVEL_4", 7), _(t, "PACKED_OP_BREAK_POINT", 8), _(t, "PACKED_OP_L_SCALE_DEPTH", 9), _(t, "PACKED_OP_R_SCALE_DEPTH", 10), _(t, "PACKED_OP_CURVES", 11), // LC and RC packed
+_(t, "PACKED_OP_RATE_SCALING", 12), // RS and DET packed
+_(t, "PACKED_OP_MOD_SENS", 13), // AMS and KVS packed
+_(t, "PACKED_OP_OUTPUT_LEVEL", 14), _(t, "PACKED_OP_MODE_FREQ", 15), // Mode and Freq Coarse packed
+_(t, "PACKED_OP_DETUNE_FINE", 16), // OSC Detune and Freq Fine packed
+// Packed voice offsets (after 6 operators = bytes 102+)
+_(t, "PACKED_PITCH_EG_RATE_1", 102), _(t, "PACKED_PITCH_EG_RATE_2", 103), _(t, "PACKED_PITCH_EG_RATE_3", 104), _(t, "PACKED_PITCH_EG_RATE_4", 105), _(t, "PACKED_PITCH_EG_LEVEL_1", 106), _(t, "PACKED_PITCH_EG_LEVEL_2", 107), _(t, "PACKED_PITCH_EG_LEVEL_3", 108), _(t, "PACKED_PITCH_EG_LEVEL_4", 109), _(t, "OFFSET_ALGORITHM", 110), _(t, "OFFSET_FEEDBACK", 111), // Also contains OSC Sync
+_(t, "OFFSET_LFO_SPEED", 112), _(t, "OFFSET_LFO_DELAY", 113), _(t, "OFFSET_LFO_PM_DEPTH", 114), _(t, "OFFSET_LFO_AM_DEPTH", 115), _(t, "OFFSET_LFO_SYNC_WAVE", 116), // LFO sync, wave, and PM sensitivity packed
+_(t, "OFFSET_TRANSPOSE", 117), _(t, "OFFSET_AMP_MOD_SENS", 118), _(t, "OFFSET_EG_BIAS_SENS", 119), // Voice name (bytes 118-127)
+// IMPORTANT: Byte 118 serves dual-purpose in DX7 hardware:
+// 1. First character of voice name (as ASCII)
+// 2. Amp Mod Sensitivity parameter (as numeric value 0-127)
+// Both interpretations are used when converting to unpacked format
+_(t, "PACKED_NAME_START", 118), _(t, "NAME_LENGTH", 10), // Unpacked format (169 bytes)
+_(t, "UNPACKED_SIZE", 169), // Total unpacked size (159 params + 10 name)
+_(t, "UNPACKED_OP_SIZE", 23), // 23 bytes per operator in unpacked format
+// Unpacked operator parameter offsets (within each 23-byte operator block)
+_(t, "UNPACKED_OP_EG_RATE_1", 0), _(t, "UNPACKED_OP_EG_RATE_2", 1), _(t, "UNPACKED_OP_EG_RATE_3", 2), _(t, "UNPACKED_OP_EG_RATE_4", 3), _(t, "UNPACKED_OP_EG_LEVEL_1", 4), _(t, "UNPACKED_OP_EG_LEVEL_2", 5), _(t, "UNPACKED_OP_EG_LEVEL_3", 6), _(t, "UNPACKED_OP_EG_LEVEL_4", 7), _(t, "UNPACKED_OP_BREAK_POINT", 8), _(t, "UNPACKED_OP_L_SCALE_DEPTH", 9), _(t, "UNPACKED_OP_R_SCALE_DEPTH", 10), _(t, "UNPACKED_OP_L_CURVE", 11), _(t, "UNPACKED_OP_R_CURVE", 12), _(t, "UNPACKED_OP_RATE_SCALING", 13), _(t, "UNPACKED_OP_DETUNE", 14), _(t, "UNPACKED_OP_AMP_MOD_SENS", 15), _(t, "UNPACKED_OP_OUTPUT_LEVEL", 16), _(t, "UNPACKED_OP_MODE", 17), // Mode (0=ratio, 1=fixed)
+_(t, "UNPACKED_OP_KEY_VEL_SENS", 18), _(t, "UNPACKED_OP_FREQ_COARSE", 19), _(t, "UNPACKED_OP_OSC_DETUNE", 20), _(t, "UNPACKED_OP_FREQ_FINE", 21), // Unpacked pitch EG offsets (after 6 operators = index 138+)
+_(t, "UNPACKED_PITCH_EG_RATE_1", 138), _(t, "UNPACKED_PITCH_EG_RATE_2", 139), _(t, "UNPACKED_PITCH_EG_RATE_3", 140), _(t, "UNPACKED_PITCH_EG_RATE_4", 141), _(t, "UNPACKED_PITCH_EG_LEVEL_1", 142), _(t, "UNPACKED_PITCH_EG_LEVEL_2", 143), _(t, "UNPACKED_PITCH_EG_LEVEL_3", 144), _(t, "UNPACKED_PITCH_EG_LEVEL_4", 145), // Unpacked global parameters (after pitch EG = index 146+)
+_(t, "UNPACKED_ALGORITHM", 146), _(t, "UNPACKED_FEEDBACK", 147), _(t, "UNPACKED_OSC_SYNC", 148), _(t, "UNPACKED_LFO_SPEED", 149), _(t, "UNPACKED_LFO_DELAY", 150), _(t, "UNPACKED_LFO_PM_DEPTH", 151), _(t, "UNPACKED_LFO_AM_DEPTH", 152), _(t, "UNPACKED_LFO_KEY_SYNC", 153), _(t, "UNPACKED_LFO_WAVE", 154), _(t, "UNPACKED_LFO_PM_SENS", 155), _(t, "UNPACKED_AMP_MOD_SENS", 156), _(t, "UNPACKED_TRANSPOSE", 157), _(t, "UNPACKED_EG_BIAS_SENS", 158), _(t, "UNPACKED_NAME_START", 159), // VCED (single voice SysEx) format - for DX7 single patch dumps
+_(t, "VCED_SIZE", 163), // Total VCED sysex size (6 header + 155 data + 1 checksum + 1 end)
+_(t, "VCED_HEADER_SIZE", 6), _(t, "VCED_DATA_SIZE", 155), // Voice data bytes (6 operators × 21 bytes + 8 pitch EG + 11 global + 10 name)
+// VCED header bytes - DX7 single voice dump format
+_(t, "VCED_SYSEX_START", 240), // SysEx Message Start
+_(t, "VCED_YAMAHA_ID", 67), // Yamaha manufacturer ID
+_(t, "VCED_SUB_STATUS", 0), _(t, "VCED_FORMAT_SINGLE", 0), // Single voice format identifier
+_(t, "VCED_BYTE_COUNT_MSB", 1), // High byte of data length (1)
+_(t, "VCED_BYTE_COUNT_LSB", 27), // Low byte of data length (27 in decimal = 155 bytes)
+_(t, "VCED_SYSEX_END", 247), // SysEx Message End
+// Bit masks
+_(t, "MASK_7BIT", 127), // Standard 7-bit MIDI data mask
+_(t, "MASK_2BIT", 3), // For 2-bit values (curves)
+_(t, "MASK_3BIT", 7), // For 3-bit values (RS, detune)
+_(t, "MASK_4BIT", 15), // For 4-bit values (detune, fine freq)
+_(t, "MASK_5BIT", 31), // For 5-bit values (algorithm, freq coarse)
+_(t, "MASK_1BIT", 1), // For 1-bit values (mode, sync)
+// Parameter value ranges
+_(t, "TRANSPOSE_CENTER", 24), // MIDI note 24 = C0 (center of DX7 transpose range: -24 to +24 semitones)
+// Special character mappings - for Japanese DX7 character set compatibility
+_(t, "CHAR_YEN", 92), // Japanese Yen symbol (¥) maps to ASCII backslash
+_(t, "CHAR_ARROW_RIGHT", 126), // Right arrow (→) maps to ASCII tilde
+_(t, "CHAR_ARROW_LEFT", 127), // Left arrow (←) maps to ASCII DEL
+_(t, "CHAR_REPLACEMENT_Y", 89), // Replace Yen symbol with "Y"
+_(t, "CHAR_REPLACEMENT_GT", 62), // Right arrow with ">"
+_(t, "CHAR_REPLACEMENT_LT", 60), // Left arrow with "<"
+_(t, "CHAR_SPACE", 32), // Standard space character
+_(t, "CHAR_MIN_PRINTABLE", 32), // Minimum ASCII printable character
+_(t, "CHAR_MAX_PRINTABLE", 126), // Maximum ASCII printable character
+// Default voice values
+_(t, "DEFAULT_EG_RATE", 99), _(t, "DEFAULT_EG_LEVEL_MAX", 99), _(t, "DEFAULT_EG_LEVEL_MIN", 0), _(t, "DEFAULT_BREAK_POINT", 0), // DX7 breakpoint 0 = A-1 (MIDI note 9)
+_(t, "DEFAULT_OUTPUT_LEVEL", 99), _(t, "DEFAULT_PITCH_EG_LEVEL", 50), _(t, "DEFAULT_LFO_SPEED", 35), _(t, "DEFAULT_LFO_PM_SENS", 3), _(t, "DEFAULT_DETUNE", 7), // Detune center (actual detune = value - 7)
+_(t, "DEFAULT_FREQ_COARSE", 1), _(t, "DEFAULT_ALGORITHM", 0), _(t, "DEFAULT_FEEDBACK", 0), _(t, "DEFAULT_OSC_SYNC", 1), _(t, "DEFAULT_LFO_KEY_SYNC", 1), // MIDI notes
+_(t, "MIDI_OCTAVE_OFFSET", -2), // For displaying MIDI notes (MIDI 0 = C-2)
+_(t, "MIDI_BREAK_POINT_OFFSET", 21);
+let K = t;
+const C = class C {
   /**
    * Create a DX7Bank instance. Can be initialized with SYX data or created empty.
    * When data is provided, it's validated and parsed. When no data is provided,
@@ -3394,12 +3245,12 @@ class l {
    * const voiceData = new Uint8Array(4096); // 32 voices × 128 bytes
    * const bank = new DX7Bank(voiceData, "Raw Bank");
    */
-  constructor(t, s = "") {
-    if (this.voices = new Array(l.NUM_VOICES), this.name = s, t)
-      this._load(t);
+  constructor(e, i = "") {
+    if (this.voices = new Array(C.NUM_VOICES), this.name = i, e)
+      this._load(e);
     else
-      for (let E = 0; E < l.NUM_VOICES; E++)
-        this.voices[E] = n.createDefault(E);
+      for (let n = 0; n < C.NUM_VOICES; n++)
+        this.voices[n] = K.createDefault(n);
   }
   /**
    * Calculate DX7 SysEx checksum
@@ -3408,55 +3259,55 @@ class l {
    * @param {number} size - Number of bytes
    * @returns {number} Checksum byte
    */
-  static _calculateChecksum(t, s) {
-    let E = 0;
-    for (let e = 0; e < s; e++)
-      E += t[e];
-    return l.CHECKSUM_MODULO - E % l.CHECKSUM_MODULO & l.MASK_7BIT;
+  static _calculateChecksum(e, i) {
+    let n = 0;
+    for (let s = 0; s < i; s++)
+      n += e[s];
+    return C.CHECKSUM_MODULO - n % C.CHECKSUM_MODULO & C.MASK_7BIT;
   }
   /**
    * Load and validate bank data
    * @private
    * @param {Array<number>|ArrayBuffer|Uint8Array} data
    */
-  _load(t) {
-    const s = t instanceof Uint8Array ? t : new Uint8Array(t);
-    let E, e = 0;
-    if (s[0] === l.SYSEX_START) {
-      const i = s.subarray(0, l.SYSEX_HEADER_SIZE), r = l.SYSEX_HEADER;
-      for (let u = 0; u < l.SYSEX_HEADER_SIZE; u++)
-        if (i[u] !== r[u])
-          throw new m(
-            `Invalid SysEx header at position ${u}: expected ${r[u].toString(16)}, got ${i[u].toString(16)}`,
+  _load(e) {
+    const i = e instanceof Uint8Array ? e : new Uint8Array(e);
+    let n, s = 0;
+    if (i[0] === C.SYSEX_START) {
+      const E = i.subarray(0, C.SYSEX_HEADER_SIZE), o = C.SYSEX_HEADER;
+      for (let l = 0; l < C.SYSEX_HEADER_SIZE; l++)
+        if (E[l] !== o[l])
+          throw new R(
+            `Invalid SysEx header at position ${l}: expected ${o[l].toString(16)}, got ${E[l].toString(16)}`,
             "header",
-            u
+            l
           );
-      E = s.subarray(l.SYSEX_HEADER_SIZE, l.SYSEX_HEADER_SIZE + l.VOICE_DATA_SIZE), e = l.SYSEX_HEADER_SIZE;
-    } else if (s.length === l.VOICE_DATA_SIZE)
-      E = s;
+      n = i.subarray(C.SYSEX_HEADER_SIZE, C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE), s = C.SYSEX_HEADER_SIZE;
+    } else if (i.length === C.VOICE_DATA_SIZE)
+      n = i;
     else
-      throw new c(
-        `Invalid data length: expected ${l.VOICE_DATA_SIZE} or ${l.SYSEX_SIZE} bytes, got ${s.length}`,
+      throw new O(
+        `Invalid data length: expected ${C.VOICE_DATA_SIZE} or ${C.SYSEX_SIZE} bytes, got ${i.length}`,
         "length",
-        s.length
+        i.length
       );
-    if (E.length !== l.VOICE_DATA_SIZE)
-      throw new c(
-        `Invalid voice data length: expected ${l.VOICE_DATA_SIZE} bytes, got ${E.length}`,
+    if (n.length !== C.VOICE_DATA_SIZE)
+      throw new O(
+        `Invalid voice data length: expected ${C.VOICE_DATA_SIZE} bytes, got ${n.length}`,
         "length",
-        E.length
+        n.length
       );
-    const _ = l.SYSEX_HEADER_SIZE + l.VOICE_DATA_SIZE;
-    if (e > 0 && s.length >= _ + 1) {
-      const i = s[_], r = l._calculateChecksum(E, l.VOICE_DATA_SIZE);
-      i !== r && console.warn(
-        `DX7 checksum mismatch (expected ${r.toString(16)}, got ${i.toString(16)}). This is common with vintage SysEx files and the data is likely still valid.`
+    const r = C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE;
+    if (s > 0 && i.length >= r + 1) {
+      const E = i[r], o = C._calculateChecksum(n, C.VOICE_DATA_SIZE);
+      E !== o && console.warn(
+        `DX7 checksum mismatch (expected ${o.toString(16)}, got ${E.toString(16)}). This is common with vintage SysEx files and the data is likely still valid.`
       );
     }
-    this.voices = new Array(l.NUM_VOICES);
-    for (let i = 0; i < l.NUM_VOICES; i++) {
-      const r = i * l.VOICE_SIZE, u = E.subarray(r, r + l.VOICE_SIZE);
-      this.voices[i] = new n(u, i);
+    this.voices = new Array(C.NUM_VOICES);
+    for (let E = 0; E < C.NUM_VOICES; E++) {
+      const o = E * C.VOICE_SIZE, l = n.subarray(o, o + C.VOICE_SIZE);
+      this.voices[E] = new K(l, E);
     }
   }
   /**
@@ -3482,22 +3333,22 @@ class l {
    * const voiceFromBank2 = bank2.getVoice(5);
    * bank1.replaceVoice(0, voiceFromBank2); // Copy voice from bank2 to bank1
    */
-  replaceVoice(t, s) {
-    if (t < 0 || t >= l.NUM_VOICES)
-      throw new c(`Invalid voice index: ${t}`, "index", t);
-    const E = new Uint8Array(s.data);
-    this.voices[t] = new n(E, t);
+  replaceVoice(e, i) {
+    if (e < 0 || e >= C.NUM_VOICES)
+      throw new O(`Invalid voice index: ${e}`, "index", e);
+    const n = new Uint8Array(i.data);
+    this.voices[e] = new K(n, e);
   }
   /**
    * Add a voice to the first empty slot
    * @param {DX7Voice} voice - Voice to add
    * @returns {number} Index where voice was added, or -1 if bank is full
    */
-  addVoice(t) {
-    for (let s = 0; s < this.voices.length; s++) {
-      const E = this.voices[s];
-      if (E.name === "" || E.name === "Init Voice")
-        return this.replaceVoice(s, t), s;
+  addVoice(e) {
+    for (let i = 0; i < this.voices.length; i++) {
+      const n = this.voices[i];
+      if (n.name === "" || n.name === "Init Voice")
+        return this.replaceVoice(i, e), i;
     }
     return -1;
   }
@@ -3513,24 +3364,24 @@ class l {
    * @param {number} index - Voice index (0-31)
    * @returns {DX7Voice|null}
    */
-  getVoice(t) {
-    return t < 0 || t >= this.voices.length ? null : this.voices[t];
+  getVoice(e) {
+    return e < 0 || e >= this.voices.length ? null : this.voices[e];
   }
   /**
    * Get all voice names
    * @returns {string[]}
    */
   getVoiceNames() {
-    return this.voices.map((t) => t.name);
+    return this.voices.map((e) => e.name);
   }
   /**
    * Find a voice by name (case-insensitive, partial match)
    * @param {string} name - Voice name to search for
    * @returns {DX7Voice|null}
    */
-  findVoiceByName(t) {
-    const s = t.toLowerCase();
-    return this.voices.find((E) => E.name.toLowerCase().includes(s)) || null;
+  findVoiceByName(e) {
+    const i = e.toLowerCase();
+    return this.voices.find((n) => n.name.toLowerCase().includes(i)) || null;
   }
   /**
    * Load a DX7 bank from a file
@@ -3540,22 +3391,22 @@ class l {
    * @throws {DX7ValidationError} If data is not valid DX7 SYX format
    * @throws {Error} If file cannot be read (FileReader error)
    */
-  static async fromFile(t) {
-    return new Promise((s, E) => {
-      const e = new FileReader();
-      e.onload = async (_) => {
+  static async fromFile(e) {
+    return new Promise((i, n) => {
+      const s = new FileReader();
+      s.onload = async (r) => {
         try {
-          const i = t.name || "", r = new Uint8Array(_.target.result);
-          if (r[0] === l.SYSEX_START && r[3] === n.VCED_FORMAT_SINGLE)
-            E(new m("This is a single voice file. Use DX7Voice.fromFile() instead.", "format", 3));
+          const E = e.name || "", o = new Uint8Array(r.target.result);
+          if (o[0] === C.SYSEX_START && o[3] === K.VCED_FORMAT_SINGLE)
+            n(new R("This is a single voice file. Use DX7Voice.fromFile() instead.", "format", 3));
           else {
-            const u = i.replace(/\.[^/.]+$/, ""), S = new l(_.target.result, u);
-            s(S);
+            const l = E.replace(/\.[^/.]+$/, ""), S = new C(r.target.result, l);
+            i(S);
           }
-        } catch (i) {
-          E(i);
+        } catch (E) {
+          n(E);
         }
-      }, e.onerror = () => E(new Error("Failed to read file")), e.readAsArrayBuffer(t);
+      }, s.onerror = () => n(new Error("Failed to read file")), s.readAsArrayBuffer(e);
     });
   }
   /**
@@ -3566,8 +3417,8 @@ class l {
    * @throws {DX7ParseError} If SysEx header is invalid
    * @throws {DX7ValidationError} If data length is invalid
    */
-  static fromSysEx(t, s = "") {
-    return new l(t, s);
+  static fromSysEx(e, i = "") {
+    return new C(e, i);
   }
   /**
    * Create a DX7Bank from a JSON object
@@ -3575,225 +3426,240 @@ class l {
    * @returns {DX7Bank}
    * @throws {DX7ValidationError} If JSON structure is invalid
    */
-  static fromJSON(t) {
-    if (!t || typeof t != "object")
-      throw new c("Invalid JSON: expected object", "json", t);
-    const s = new l();
-    if (s.name = t.name || "", !Array.isArray(t.voices))
-      throw new c("Invalid voices array", "voices", t.voices);
-    t.voices.length !== l.NUM_VOICES && console.warn(
-      `Bank JSON has ${t.voices.length} voices, expected ${l.NUM_VOICES}. Missing voices will be filled with defaults.`
+  static fromJSON(e) {
+    if (!e || typeof e != "object")
+      throw new O("Invalid JSON: expected object", "json", e);
+    const i = new C();
+    if (i.name = e.name || "", !Array.isArray(e.voices))
+      throw new O("Invalid voices array", "voices", e.voices);
+    e.voices.length !== C.NUM_VOICES && console.warn(
+      `Bank JSON has ${e.voices.length} voices, expected ${C.NUM_VOICES}. Missing voices will be filled with defaults.`
     );
-    const E = Math.min(t.voices.length, l.NUM_VOICES);
-    for (let e = 0; e < E; e++) {
-      const _ = t.voices[e];
-      if (!_ || typeof _ != "object") {
-        console.warn(`Invalid voice data at index ${e}, using default voice`);
+    const n = Math.min(e.voices.length, C.NUM_VOICES);
+    for (let s = 0; s < n; s++) {
+      const r = e.voices[s];
+      if (!r || typeof r != "object") {
+        console.warn(`Invalid voice data at index ${s}, using default voice`);
         continue;
       }
       try {
-        const { index: i, ...r } = _, u = n.fromJSON(r, e);
-        s.replaceVoice(e, u);
-      } catch (i) {
-        console.warn(`Failed to load voice at index ${e}: ${i.message}, using default voice`);
+        const { index: E, ...o } = r, l = K.fromJSON(o, s);
+        i.replaceVoice(s, l);
+      } catch (E) {
+        console.warn(`Failed to load voice at index ${s}: ${E.message}, using default voice`);
       }
     }
-    return s;
+    return i;
   }
   /**
    * Export bank to SysEx format
    * @returns {Uint8Array} Full SysEx data (4104 bytes)
    */
   toSysEx() {
-    const t = new Uint8Array(l.SYSEX_SIZE);
-    let s = 0;
-    l.SYSEX_HEADER.forEach((e) => {
-      t[s++] = e;
+    const e = new Uint8Array(C.SYSEX_SIZE);
+    let i = 0;
+    C.SYSEX_HEADER.forEach((s) => {
+      e[i++] = s;
     });
-    for (const e of this.voices)
-      for (let _ = 0; _ < l.VOICE_SIZE; _++)
-        t[s++] = e.data[_];
-    const E = t.subarray(l.SYSEX_HEADER_SIZE, l.SYSEX_HEADER_SIZE + l.VOICE_DATA_SIZE);
-    return t[s++] = l._calculateChecksum(E, l.VOICE_DATA_SIZE), t[s++] = l.SYSEX_END, t;
+    for (const s of this.voices)
+      for (let r = 0; r < C.VOICE_SIZE; r++)
+        e[i++] = s.data[r];
+    const n = e.subarray(C.SYSEX_HEADER_SIZE, C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE);
+    return e[i++] = C._calculateChecksum(n, C.VOICE_DATA_SIZE), e[i++] = C.SYSEX_END, e;
   }
   /**
    * Convert bank to JSON format
    * @returns {object} Bank data in JSON format
    */
   toJSON() {
-    const t = this.voices.map((s, E) => {
-      const e = s.toJSON();
+    const e = this.voices.map((i, n) => {
+      const s = i.toJSON();
       return {
-        index: E + 1,
-        ...e
+        index: n + 1,
+        ...s
       };
     });
     return {
       version: "1.0",
       name: this.name || "",
-      voices: t
+      voices: e
     };
   }
-}
-function nt(A) {
-  return A[0] !== 240 || A[A.length - 1] !== 247 ? null : {
-    manufacturerId: A[1],
-    payload: A.slice(2, -1),
-    raw: A
+};
+// SysEx header
+_(C, "SYSEX_START", 240), _(C, "SYSEX_END", 247), _(C, "SYSEX_YAMAHA_ID", 67), _(C, "SYSEX_SUB_STATUS", 0), _(C, "SYSEX_FORMAT_32_VOICES", 9), _(C, "SYSEX_BYTE_COUNT_MSB", 32), _(C, "SYSEX_BYTE_COUNT_LSB", 0), _(C, "SYSEX_HEADER", [
+  C.SYSEX_START,
+  C.SYSEX_YAMAHA_ID,
+  C.SYSEX_SUB_STATUS,
+  C.SYSEX_FORMAT_32_VOICES,
+  C.SYSEX_BYTE_COUNT_MSB,
+  C.SYSEX_BYTE_COUNT_LSB
+]), _(C, "SYSEX_HEADER_SIZE", 6), // Bank structure
+_(C, "VOICE_DATA_SIZE", 4096), // 32 voices × 128 bytes
+_(C, "SYSEX_SIZE", 4104), // Header(6) + Data(4096) + Checksum(1) + End(1)
+_(C, "VOICE_SIZE", 128), // Bytes per voice in packed format
+_(C, "NUM_VOICES", 32), // Checksum
+_(C, "CHECKSUM_MODULO", 128), _(C, "MASK_7BIT", 127);
+let M = C;
+function ot(c) {
+  return c[0] !== 240 || c[c.length - 1] !== 247 ? null : {
+    manufacturerId: c[1],
+    payload: c.slice(2, -1),
+    raw: c
   };
 }
-function st(A, t) {
-  return [240, A, ...t, 247];
+function _t(c, e) {
+  return [240, c, ...e, 247];
 }
-function Et(A) {
-  return A.length >= 2 && A[0] === 240 && A[A.length - 1] === 247;
+function at(c) {
+  return c.length >= 2 && c[0] === 240 && c[c.length - 1] === 247;
 }
-function et(A) {
-  const t = [];
-  for (let s = 0; s < A.length; s += 7) {
-    const E = A.slice(s, s + 7);
-    let e = 0;
-    const _ = [];
-    for (let i = 0; i < E.length; i++) {
-      const r = E[i];
-      r & 128 && (e |= 1 << i), _.push(r & 127);
-    }
-    t.push(e, ..._);
-  }
-  return t;
+function ct(c) {
+  const e = [];
+  for (let i = 0; i < c.length; i += 7) {
+    const n = c.slice(i, i + 7);
+    let s = 0;
+    const r = [];
+    for (let E = 0; E < n.length; E++) {
+      const o = n[E];
+      o & 128 && (s |= 1 << E), r.push(o & 127);
+    }
+    e.push(s, ...r);
+  }
+  return e;
 }
-function it(A) {
-  const t = [];
-  for (let s = 0; s < A.length; s += 8) {
-    const E = A[s], e = Math.min(7, A.length - s - 1);
-    for (let _ = 0; _ < e; _++) {
-      let i = A[s + 1 + _];
-      E & 1 << _ && (i |= 128), t.push(i);
+function At(c) {
+  const e = [];
+  for (let i = 0; i < c.length; i += 8) {
+    const n = c[i], s = Math.min(7, c.length - i - 1);
+    for (let r = 0; r < s; r++) {
+      let E = c[i + 1 + r];
+      n & 1 << r && (E |= 128), e.push(E);
     }
   }
-  return t;
+  return e;
 }
-function _t(A) {
-  return Number.isInteger(A) && A >= 1 && A <= 16;
+function Ct(c) {
+  return Number.isInteger(c) && c >= 1 && c <= 16;
 }
-function rt(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 127;
+function Pt(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 127;
 }
-function at(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 31;
+function ut(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 31;
 }
-function At(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 127;
+function lt(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 127;
 }
-function ot(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 127;
+function ht(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 127;
 }
-function Ct(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 127;
+function St(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 127;
 }
-function Pt(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 127;
+function Nt(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 127;
 }
-function ut(A) {
-  return Number.isInteger(A) && A >= 0 && A <= 16383;
+function Dt(c) {
+  return Number.isInteger(c) && c >= 0 && c <= 16383;
 }
-function lt(A, t) {
-  return Number.isInteger(A) && A >= 0 && A <= 127 && Number.isInteger(t) && t >= 0 && t <= 127;
+function Ot(c, e) {
+  return Number.isInteger(c) && c >= 0 && c <= 127 && Number.isInteger(e) && e >= 0 && e <= 127;
 }
-async function ht(A = {}) {
+async function dt(c = {}) {
   const {
-    onStatusUpdate: t,
-    onConnectionUpdate: s,
-    inputChannel: E = 1,
-    outputChannel: e = 1,
-    output: _,
-    sysex: i,
-    onReady: r,
-    onError: u,
+    onStatusUpdate: e,
+    onConnectionUpdate: i,
+    inputChannel: n = 1,
+    outputChannel: s = 1,
+    output: r,
+    sysex: E,
+    onReady: o,
+    onError: l,
     selector: S,
-    watchDOM: P,
+    watchDOM: u,
     ...a
-  } = A, h = await W({
+  } = c, h = await j({
     autoConnect: !1,
-    sysex: i,
-    inputChannel: E,
-    outputChannel: e,
+    sysex: E,
+    inputChannel: n,
+    outputChannel: s,
     selector: S || "[data-midi-cc]",
-    watchDOM: P,
-    onError: u,
+    watchDOM: u,
+    onError: l,
     ...a
-  }), N = new q({
+  }), N = new k({
     midiController: h,
-    onStatusUpdate: t || (() => {
+    onStatusUpdate: e || (() => {
     }),
-    onConnectionUpdate: s || (() => {
+    onConnectionUpdate: i || (() => {
     }),
-    channel: e
+    channel: s
   });
-  if (_)
+  if (r)
     try {
-      await h.device.connectOutput(_), N.currentOutput = h.device.getCurrentOutput(), N.updateConnectionStatus();
+      await h.device.connectOutput(r), N.currentOutput = h.device.getCurrentOutput(), N.updateConnectionStatus();
     } catch (d) {
-      u ? u(d) : console.error("Failed to connect to MIDI device:", d.message);
+      l ? l(d) : console.error("Failed to connect to MIDI device:", d.message);
     }
-  return r && r(h, N), N;
+  return o && o(h, N), N;
 }
-async function W(A = {}) {
-  const t = new z(A);
-  await t.init();
-  const s = A.selector || "[data-midi-cc]";
+async function j(c = {}) {
+  const e = new J(c);
+  await e.init();
+  const i = c.selector || "[data-midi-cc]";
   {
-    const E = new w(t, s);
-    E.bindAll(), A.watchDOM && E.enableAutoBinding(), t._binder = E;
+    const n = new $(e, i);
+    n.bindAll(), c.watchDOM && n.enableAutoBinding(), e._binder = n;
   }
-  return t;
+  return e;
 }
 export {
-  U as CONN,
-  U as CONNECTION_EVENTS,
-  C as CONTROLLER_EVENTS,
-  C as CTRL,
-  l as DX7Bank,
-  b as DX7Error,
-  m as DX7ParseError,
-  c as DX7ValidationError,
-  n as DX7Voice,
-  w as DataAttributeBinder,
-  H as EventEmitter,
-  g as MIDIAccessError,
-  Z as MIDIConnection,
-  F as MIDIConnectionError,
-  z as MIDIController,
-  K as MIDIDeviceError,
-  q as MIDIDeviceManager,
-  R as MIDIError,
-  L as MIDIValidationError,
-  O as clamp,
-  W as createMIDIController,
-  ht as createMIDIDeviceManager,
-  st as createSysEx,
-  Y as decode14BitValue,
-  it as decode7Bit,
-  tt as denormalize14BitValue,
-  Q as denormalizeValue,
-  B as encode14BitValue,
-  et as encode7Bit,
-  k as frequencyToNote,
-  X as getCCName,
-  Et as isSysEx,
-  at as isValid14BitCC,
-  rt as isValidCC,
-  _t as isValidChannel,
-  At as isValidMIDIValue,
-  ot as isValidNote,
-  ut as isValidPitchBend,
-  lt as isValidPitchBendBytes,
-  Pt as isValidProgramChange,
-  Ct as isValidVelocity,
-  $ as normalize14BitValue,
-  x as normalizeValue,
-  J as noteNameToNumber,
-  j as noteNumberToName,
-  V as noteToFrequency,
-  nt as parseSysEx
+  p as CONN,
+  p as CONNECTION_EVENTS,
+  P as CONTROLLER_EVENTS,
+  P as CTRL,
+  M as DX7Bank,
+  v as DX7Error,
+  R as DX7ParseError,
+  O as DX7ValidationError,
+  K as DX7Voice,
+  $ as DataAttributeBinder,
+  w as EventEmitter,
+  F as MIDIAccessError,
+  Q as MIDIConnection,
+  y as MIDIConnectionError,
+  J as MIDIController,
+  U as MIDIDeviceError,
+  k as MIDIDeviceManager,
+  g as MIDIError,
+  m as MIDIValidationError,
+  D as clamp,
+  j as createMIDIController,
+  dt as createMIDIDeviceManager,
+  _t as createSysEx,
+  q as decode14BitValue,
+  At as decode7Bit,
+  rt as denormalize14BitValue,
+  tt as denormalizeValue,
+  z as encode14BitValue,
+  ct as encode7Bit,
+  nt as frequencyToNote,
+  Et as getCCName,
+  at as isSysEx,
+  ut as isValid14BitCC,
+  Pt as isValidCC,
+  Ct as isValidChannel,
+  lt as isValidMIDIValue,
+  ht as isValidNote,
+  Dt as isValidPitchBend,
+  Ot as isValidPitchBendBytes,
+  Nt as isValidProgramChange,
+  St as isValidVelocity,
+  W as normalize14BitValue,
+  Z as normalizeValue,
+  et as noteNameToNumber,
+  it as noteNumberToName,
+  st as noteToFrequency,
+  ot as parseSysEx
 };