midiwire 0.1.0

package/dist/midiwire.es.js

@@ -0,0 +1,1987 @@
+class B {
+  /**
+   * @param {import("../core/MIDIController.js").MIDIController} controller
+   * @param {string} selector - CSS selector for elements to bind
+   */
+  constructor(E, s = "[data-midi-cc]") {
+    this.controller = E, this.selector = s, this.observer = null;
+  }
+  /**
+   * Bind all matching elements in the document
+   */
+  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 n = this._parseAttributes(s);
+      n && (this.controller.bind(s, n), s.setAttribute("data-midi-bound", "true"));
+    });
+  }
+  /**
+   * Watch for dynamically added elements and auto-bind them
+   */
+  enableAutoBinding() {
+    if (this.observer) return;
+    const E = this.selector === "[data-midi-cc]" ? "[data-midi-cc], [data-midi-msb][data-midi-lsb]" : this.selector;
+    this.observer = new MutationObserver((s) => {
+      s.forEach((n) => {
+        n.addedNodes.forEach((_) => {
+          if (_.nodeType === Node.ELEMENT_NODE) {
+            if (_.matches?.(E)) {
+              const A = this._parseAttributes(_);
+              A && !_.hasAttribute("data-midi-bound") && (this.controller.bind(_, A), _.setAttribute("data-midi-bound", "true"));
+            }
+            _.querySelectorAll && _.querySelectorAll(E).forEach((e) => {
+              if (!e.hasAttribute("data-midi-bound")) {
+                const r = this._parseAttributes(e);
+                r && (this.controller.bind(e, r), e.setAttribute("data-midi-bound", "true"));
+              }
+            });
+          }
+        }), n.removedNodes.forEach((_) => {
+          _.nodeType === Node.ELEMENT_NODE && (_.hasAttribute?.("data-midi-bound") && this.controller.unbind(_), _.querySelectorAll && _.querySelectorAll("[data-midi-bound]").forEach((e) => {
+            this.controller.unbind(e);
+          }));
+        });
+      });
+    }), this.observer.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    });
+  }
+  /**
+   * Stop watching for new elements
+   */
+  disableAutoBinding() {
+    this.observer && (this.observer.disconnect(), this.observer = null);
+  }
+  /**
+   * Parse MIDI config from data attributes
+   * @param {HTMLElement} element
+   * @returns {Object|null}
+   * @private
+   */
+  _parseAttributes(E) {
+    const s = parseInt(E.dataset.midiMsb, 10), n = parseInt(E.dataset.midiLsb, 10);
+    if (!Number.isNaN(s) && !Number.isNaN(n) && s >= 0 && s <= 127 && n >= 0 && n <= 127) {
+      const A = parseInt(E.dataset.midiCc, 10);
+      return !Number.isNaN(A) && A >= 0 && A <= 127 && console.warn(
+        `Element has both 7-bit (data-midi-cc="${A}") and 14-bit (data-midi-msb="${s}" data-midi-lsb="${n}") CC attributes. 14-bit takes precedence.`,
+        E
+      ), {
+        msb: s,
+        lsb: n,
+        is14Bit: !0,
+        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 _ = parseInt(E.dataset.midiCc, 10);
+    return !Number.isNaN(_) && _ >= 0 && _ <= 127 ? {
+      cc: _,
+      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
+   */
+  destroy() {
+    this.disableAutoBinding();
+  }
+}
+class M extends Error {
+  constructor(E, s) {
+    super(E), this.name = "MIDIError", this.code = s, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+}
+class p extends M {
+  constructor(E, s) {
+    super(E, "MIDI_ACCESS_ERROR"), this.name = "MIDIAccessError", this.reason = s;
+  }
+}
+class g extends M {
+  constructor(E) {
+    super(E, "MIDI_CONNECTION_ERROR"), this.name = "MIDIConnectionError";
+  }
+}
+class f extends M {
+  constructor(E, s, n) {
+    super(E, "MIDI_DEVICE_ERROR"), this.name = "MIDIDeviceError", this.deviceType = s, this.deviceId = n;
+  }
+}
+class m extends M {
+  constructor(E, s) {
+    super(E, "MIDI_VALIDATION_ERROR"), this.name = "MIDIValidationError", this.validationType = s;
+  }
+}
+class H extends Error {
+  constructor(E, s) {
+    super(E), this.name = "DX7Error", this.code = s, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+}
+class D extends H {
+  constructor(E, s, n) {
+    super(E, "DX7_PARSE_ERROR"), this.name = "DX7ParseError", this.parseType = s, this.offset = n;
+  }
+}
+class c extends H {
+  constructor(E, s, n) {
+    super(E, "DX7_VALIDATION_ERROR"), this.name = "DX7ValidationError", this.validationType = s, this.value = n;
+  }
+}
+function O(a, E, s) {
+  return Math.max(E, Math.min(s, a));
+}
+function w(a, E, s, n = !1) {
+  const _ = (a - E) / (s - E), e = (n ? 1 - _ : _) * 127;
+  return O(Math.round(e), 0, 127);
+}
+function Q(a, E, s, n = !1) {
+  let _ = O(a, 0, 127) / 127;
+  return n && (_ = 1 - _), E + _ * (s - E);
+}
+function j(a) {
+  const E = {
+    C: 0,
+    "C#": 1,
+    DB: 1,
+    D: 2,
+    "D#": 3,
+    EB: 3,
+    E: 4,
+    F: 5,
+    "F#": 6,
+    GB: 6,
+    G: 7,
+    "G#": 8,
+    AB: 8,
+    A: 9,
+    "A#": 10,
+    BB: 10,
+    B: 11
+  }, s = a.match(/^([A-G][#b]?)(-?\d+)$/i);
+  if (!s)
+    throw new m(`Invalid note name: ${a}`, "note", a);
+  const [, n, _] = s, A = E[n.toUpperCase()];
+  if (A === void 0)
+    throw new m(`Invalid note: ${n}`, "note", n);
+  const e = (parseInt(_, 10) + 1) * 12 + A;
+  return O(e, 0, 127);
+}
+function J(a, E = !1) {
+  const _ = 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"], A = Math.floor(a / 12) - 1;
+  return `${_[a % 12]}${A}`;
+}
+function k(a) {
+  const E = 69 + 12 * Math.log2(a / 440);
+  return O(Math.round(E), 0, 127);
+}
+function V(a) {
+  return 440 * 2 ** ((a - 69) / 12);
+}
+function X(a) {
+  return {
+    0: "Bank Select",
+    1: "Modulation",
+    2: "Breath Controller",
+    4: "Foot Controller",
+    5: "Portamento Time",
+    7: "Volume",
+    8: "Balance",
+    10: "Pan",
+    11: "Expression",
+    64: "Sustain Pedal",
+    65: "Portamento",
+    66: "Sostenuto",
+    67: "Soft Pedal",
+    68: "Legato",
+    71: "Resonance",
+    72: "Release Time",
+    73: "Attack Time",
+    74: "Cutoff",
+    75: "Decay Time",
+    76: "Vibrato Rate",
+    77: "Vibrato Depth",
+    78: "Vibrato Delay",
+    84: "Portamento Control",
+    91: "Reverb",
+    92: "Tremolo",
+    93: "Chorus",
+    94: "Detune",
+    95: "Phaser",
+    120: "All Sound Off",
+    121: "Reset All Controllers",
+    123: "All Notes Off"
+  }[a] || `CC ${a}`;
+}
+function x(a) {
+  const E = O(Math.round(a), 0, 16383);
+  return {
+    msb: E >> 7 & 127,
+    lsb: E & 127
+  };
+}
+function Y(a, E) {
+  return O(a, 0, 127) << 7 | O(E, 0, 127);
+}
+function Z(a, E, s, n = !1) {
+  const _ = (a - E) / (s - E), e = (n ? 1 - _ : _) * 16383;
+  return x(e);
+}
+function tt(a, E, s, n, _ = !1) {
+  let e = Y(a, E) / 16383;
+  return _ && (e = 1 - e), s + e * (n - s);
+}
+class b {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register an event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   * @returns {Function} Unsubscribe function
+   */
+  on(E, s) {
+    return this.events.has(E) || this.events.set(E, []), this.events.get(E).push(s), () => this.off(E, s);
+  }
+  /**
+   * Register a one-time event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   */
+  once(E, s) {
+    const n = (..._) => {
+      s(..._), this.off(E, n);
+    };
+    this.on(E, n);
+  }
+  /**
+   * Remove an event listener
+   * @param {string} event - Event name
+   * @param {Function} handler - Event handler function
+   */
+  off(E, s) {
+    if (!this.events.has(E)) return;
+    const n = this.events.get(E), _ = n.indexOf(s);
+    _ > -1 && n.splice(_, 1), n.length === 0 && this.events.delete(E);
+  }
+  /**
+   * Emit an event
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+  emit(E, s) {
+    if (!this.events.has(E)) return;
+    [...this.events.get(E)].forEach((_) => {
+      try {
+        _(s);
+      } catch (A) {
+        console.error(`Error in event handler for "${E}":`, A);
+      }
+    });
+  }
+  /**
+   * Remove all event listeners
+   * @param {string} [event] - Optional event name to clear specific event
+   */
+  removeAllListeners(E) {
+    E ? this.events.delete(E) : this.events.clear();
+  }
+}
+const d = {
+  DEVICE_CHANGE: "device-change",
+  INPUT_DEVICE_CONNECTED: "input-device-connected",
+  INPUT_DEVICE_DISCONNECTED: "input-device-disconnected",
+  OUTPUT_DEVICE_CONNECTED: "output-device-connected",
+  OUTPUT_DEVICE_DISCONNECTED: "output-device-disconnected"
+};
+class $ extends b {
+  /**
+   * @param {Object} options
+   * @param {boolean} [options.sysex=false] - Request SysEx access
+   */
+  constructor(E = {}) {
+    super(), this.options = {
+      sysex: !1,
+      ...E
+    }, this.midiAccess = null, this.output = null, this.input = null;
+  }
+  /**
+   * Request MIDI access from the browser
+   * @returns {Promise<void>}
+   * @throws {MIDIAccessError} If MIDI is not supported or access is denied
+   */
+  async requestAccess() {
+    if (!navigator.requestMIDIAccess)
+      throw new p("Web MIDI API is not supported in this browser", "unsupported");
+    try {
+      this.midiAccess = await navigator.requestMIDIAccess({
+        sysex: this.options.sysex
+      }), this.midiAccess.onstatechange = (E) => {
+        const s = E.port, n = E.port.state;
+        this.emit(d.DEVICE_CHANGE, {
+          port: s,
+          state: n,
+          type: s.type,
+          device: {
+            id: s.id,
+            name: s.name,
+            manufacturer: s.manufacturer || "Unknown"
+          }
+        }), n === "disconnected" ? s.type === "input" ? (this.emit(d.INPUT_DEVICE_DISCONNECTED, { device: s }), this.input && this.input.id === s.id && (this.input = null)) : s.type === "output" && (this.emit(d.OUTPUT_DEVICE_DISCONNECTED, { device: s }), this.output && this.output.id === s.id && (this.output = null)) : n === "connected" && (s.type === "input" ? this.emit(d.INPUT_DEVICE_CONNECTED, { device: s }) : s.type === "output" && this.emit(d.OUTPUT_DEVICE_CONNECTED, { device: s }));
+      };
+    } catch (E) {
+      throw E.name === "SecurityError" ? new p("MIDI access denied. SysEx requires user permission.", "denied") : new p(`Failed to get MIDI access: ${E.message}`, "failed");
+    }
+  }
+  /**
+   * Get all available MIDI outputs
+   * @returns {Array<{id: string, name: string, manufacturer: string}>}
+   */
+  getOutputs() {
+    if (!this.midiAccess) return [];
+    const E = [];
+    return this.midiAccess.outputs.forEach((s) => {
+      s.state === "connected" && E.push({
+        id: s.id,
+        name: s.name,
+        manufacturer: s.manufacturer || "Unknown"
+      });
+    }), E;
+  }
+  /**
+   * Get all available MIDI inputs
+   * @returns {Array<{id: string, name: string, manufacturer: string}>}
+   */
+  getInputs() {
+    if (!this.midiAccess) return [];
+    const E = [];
+    return this.midiAccess.inputs.forEach((s) => {
+      s.state === "connected" && E.push({
+        id: s.id,
+        name: s.name,
+        manufacturer: s.manufacturer || "Unknown"
+      });
+    }), E;
+  }
+  /**
+   * Connect to a MIDI output device
+   * @param {string|number} [device] - Device name, ID, or index (defaults to first available)
+   * @returns {Promise<void>}
+   * @throws {MIDIConnectionError} If MIDI access not initialized
+   * @throws {MIDIDeviceError} If device not found or index out of range
+   */
+  async connect(E) {
+    if (!this.midiAccess)
+      throw new g("MIDI access not initialized. Call requestAccess() first.");
+    const s = Array.from(this.midiAccess.outputs.values());
+    if (s.length === 0)
+      throw new f("No MIDI output devices available", "output");
+    if (E === void 0) {
+      this.output = s[0];
+      return;
+    }
+    if (typeof E == "number") {
+      if (E < 0 || E >= s.length)
+        throw new f(
+          `Output index ${E} out of range (0-${s.length - 1})`,
+          "output",
+          E
+        );
+      this.output = s[E];
+      return;
+    }
+    if (this.output = s.find((n) => n.name === E || n.id === E), !this.output) {
+      const n = s.map((_) => _.name).join(", ");
+      throw new f(
+        `MIDI output "${E}" not found. Available: ${n}`,
+        "output",
+        E
+      );
+    }
+  }
+  /**
+   * Connect to a MIDI input device for receiving messages
+   * @param {string|number} [device] - Device name, ID, or index (defaults to first available)
+   * @param {Function} onMessage - Callback for incoming MIDI messages
+   * @returns {Promise<void>}
+   * @throws {MIDIConnectionError} If MIDI access not initialized
+   * @throws {MIDIValidationError} If onMessage is not a function
+   * @throws {MIDIDeviceError} If device not found or index out of range
+   */
+  async connectInput(E, s) {
+    if (!this.midiAccess)
+      throw new g("MIDI access not initialized. Call requestAccess() first.");
+    if (typeof s != "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 f("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 f(
+          `Input index ${E} out of range (0-${n.length - 1})`,
+          "input",
+          E
+        );
+      this.input = n[E];
+    } else if (this.input = n.find((_) => _.name === E || _.id === E), !this.input) {
+      const _ = n.map((A) => A.name).join(", ");
+      throw new f(
+        `MIDI input "${E}" not found. Available: ${_}`,
+        "input",
+        E
+      );
+    }
+    this.input.onmidimessage = (_) => {
+      s(_);
+    };
+  }
+  /**
+   * Send a MIDI message
+   * @param {Uint8Array|Array<number>} message - MIDI message bytes
+   * @param {number} [timestamp=performance.now()] - Optional timestamp
+   */
+  send(E, s = null) {
+    if (!this.output) {
+      console.warn("No MIDI output connected. Call connect() first.");
+      return;
+    }
+    try {
+      const n = new Uint8Array(E);
+      s === null ? this.output.send(n) : this.output.send(n, s);
+    } catch (n) {
+      console.error("Failed to send MIDI message:", n);
+    }
+  }
+  /**
+   * Send a SysEx message
+   * @param {Array<number>} data - SysEx data bytes (without F0/F7 wrapper)
+   * @param {boolean} [includeWrapper=false] - If true, data already includes F0/F7
+   */
+  sendSysEx(E, s = !1) {
+    if (!this.options.sysex) {
+      console.warn("SysEx not enabled. Initialize with sysex: true");
+      return;
+    }
+    let n;
+    s ? n = [240, ...E, 247] : n = E, this.send(n);
+  }
+  /**
+   * Disconnect from current output and input
+   */
+  disconnect() {
+    this.input && (this.input.onmidimessage = null, this.input = null), this.output = null;
+  }
+  /**
+   * Check if currently connected to an output
+   * @returns {boolean}
+   */
+  isConnected() {
+    return this.output !== null;
+  }
+  /**
+   * Get current output device info
+   * @returns {Object|null}
+   */
+  getCurrentOutput() {
+    return this.output ? {
+      id: this.output.id,
+      name: this.output.name,
+      manufacturer: this.output.manufacturer || "Unknown"
+    } : null;
+  }
+  /**
+   * Get current input device info
+   * @returns {Object|null}
+   */
+  getCurrentInput() {
+    return this.input ? {
+      id: this.input.id,
+      name: this.input.name,
+      manufacturer: this.input.manufacturer || "Unknown"
+    } : null;
+  }
+}
+const o = {
+  READY: "ready",
+  ERROR: "error",
+  CC_SEND: "cc-send",
+  CC_RECV: "cc-recv",
+  NOTE_ON_SEND: "note-on-send",
+  NOTE_ON_RECV: "note-on-recv",
+  NOTE_OFF_SEND: "note-off-send",
+  NOTE_OFF_RECV: "note-off-recv",
+  SYSEX_SEND: "sysex-send",
+  SYSEX_RECV: "sysex-recv",
+  OUTPUT_CHANGED: "output-changed",
+  INPUT_CONNECTED: "input-connected",
+  DESTROYED: "destroyed",
+  MIDI_MSG: "midi-msg",
+  PATCH_SAVED: "patch-saved",
+  PATCH_LOADED: "patch-loaded",
+  PATCH_DELETED: "patch-deleted"
+};
+class z extends b {
+  /**
+   * @param {Object} options
+   * @param {number} [options.channel=1] - Default MIDI channel (1-16)
+   * @param {string|number} [options.output] - MIDI output device
+   * @param {string|number} [options.input] - MIDI input device
+   * @param {boolean} [options.sysex=false] - Request SysEx access
+   * @param {boolean} [options.autoConnect=true] - Auto-connect to first available output
+   * @param {Function} [options.onReady] - Callback when MIDI is ready
+   * @param {Function} [options.onError] - Error handler
+   */
+  constructor(E = {}) {
+    super(), this.options = {
+      channel: 1,
+      autoConnect: !0,
+      sysex: !1,
+      ...E
+    }, this.connection = null, this.bindings = /* @__PURE__ */ new Map(), this.state = /* @__PURE__ */ new Map(), this.initialized = !1;
+  }
+  /**
+   * Initialize MIDI access
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (this.initialized) {
+      console.warn("MIDI Controller already initialized");
+      return;
+    }
+    try {
+      this.connection = new $({
+        sysex: this.options.sysex
+      }), await this.connection.requestAccess(), 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(o.READY, this), this.options.onReady?.(this);
+    } catch (E) {
+      throw this.emit(o.ERROR, E), this.options.onError?.(E), E;
+    }
+  }
+  /**
+   * Connect to a MIDI input device for receiving messages
+   * @param {string|number} device - Device name, ID, or index
+   * @returns {Promise<void>}
+   */
+  async connectInput(E) {
+    await this.connection.connectInput(E, (s) => {
+      this._handleMIDIMessage(s);
+    }), this.emit(o.INPUT_CONNECTED, this.connection.getCurrentInput());
+  }
+  /**
+   * Send a control change message
+   * @param {number} cc - CC number (0-127)
+   * @param {number} value - CC value (0-127)
+   * @param {number} [channel] - MIDI channel (defaults to controller channel)
+   */
+  sendCC(E, s, n = this.options.channel) {
+    if (!this.initialized) {
+      console.warn("MIDI not initialized. Call initialize() first.");
+      return;
+    }
+    E = O(Math.round(E), 0, 127), s = O(Math.round(s), 0, 127), n = O(Math.round(n), 1, 16);
+    const _ = 176 + (n - 1);
+    this.connection.send([_, E, s]);
+    const A = `${n}:${E}`;
+    this.state.set(A, s), this.emit(o.CC_SEND, { cc: E, value: s, channel: n });
+  }
+  /**
+   * Send a SysEx message
+   * @param {Array<number>} data - SysEx data bytes (without F0/F7 wrapper)
+   * @param {boolean} [includeWrapper=false] - If true, data already includes F0/F7
+   *
+   * @example
+   * // Send with wrapper included
+   * midi.sendSysEx([0xF0, 0x42, 0x30, 0x00, 0x01, 0x2F, 0x12, 0xF7], true)
+   */
+  sendSysEx(E, s = !1) {
+    if (!this.initialized) {
+      console.warn("MIDI not initialized. Call initialize() first.");
+      return;
+    }
+    if (!this.options.sysex) {
+      console.warn("SysEx not enabled. Initialize with sysex: true");
+      return;
+    }
+    this.connection.sendSysEx(E, s), this.emit(o.SYSEX_SEND, { data: E, includeWrapper: s });
+  }
+  /**
+   * Send a note on message
+   * @param {number} note - Note number (0-127)
+   * @param {number} [velocity=64] - Note velocity (0-127)
+   * @param {number} [channel] - MIDI channel
+   */
+  sendNoteOn(E, s = 64, n = this.options.channel) {
+    if (!this.initialized) return;
+    E = O(Math.round(E), 0, 127), s = O(Math.round(s), 0, 127), n = O(Math.round(n), 1, 16);
+    const _ = 144 + (n - 1);
+    this.connection.send([_, E, s]), this.emit(o.NOTE_ON_SEND, { note: E, velocity: s, channel: n });
+  }
+  /**
+   * Send a note off message
+   * @param {number} note - Note number (0-127)
+   * @param {number} [channel] - MIDI channel
+   * @param {number} [velocity=0] - Release velocity (0-127)
+   */
+  sendNoteOff(E, s = this.options.channel, n = 0) {
+    if (!this.initialized) return;
+    E = O(Math.round(E), 0, 127), n = O(Math.round(n), 0, 127), s = O(Math.round(s), 1, 16);
+    const _ = 144 + (s - 1);
+    this.connection.send([_, E, n]), this.emit(o.NOTE_OFF_SEND, { note: E, channel: s, velocity: n });
+  }
+  /**
+   * Bind a control programmatically
+   * @param {HTMLElement} element - DOM element
+   * @param {Object} config - Binding configuration
+   * @param {number} config.cc - CC number
+   * @param {number} [config.min=0] - Minimum input value
+   * @param {number} [config.max=127] - Maximum input value
+   * @param {number} [config.channel] - Override channel
+   * @param {boolean} [config.invert=false] - Invert the value
+   * @param {Function} [config.onInput] - Optional callback for value updates (receives normalized element value)
+   * @param {Object} [options={}] - Additional options
+   * @param {number} [options.debounce=0] - Debounce delay in ms for high-frequency updates
+   * @returns {Function} Unbind function
+   */
+  bind(E, s, n = {}) {
+    if (!E)
+      return console.warn("Cannot bind: element is null or undefined"), () => {
+      };
+    const _ = this._createBinding(E, s, n);
+    return this.bindings.set(E, _), this.initialized && this.connection?.isConnected() && _.handler({ target: E }), () => this.unbind(E);
+  }
+  /**
+   * Unbind a control
+   * @param {HTMLElement} element
+   */
+  unbind(E) {
+    const s = this.bindings.get(E);
+    s && (s.destroy(), this.bindings.delete(E));
+  }
+  /**
+   * Get current value of a CC
+   * @param {number} cc - CC number
+   * @param {number} [channel] - MIDI channel
+   * @returns {number|undefined}
+   */
+  getCC(E, s = this.options.channel) {
+    const n = `${s}:${E}`;
+    return this.state.get(n);
+  }
+  /**
+   * Get all available MIDI outputs
+   * @returns {Array<{id: string, name: string, manufacturer: string}>}
+   */
+  getOutputs() {
+    return this.connection?.getOutputs() || [];
+  }
+  /**
+   * Get all available MIDI inputs
+   * @returns {Array<{id: string, name: string, manufacturer: string}>}
+   */
+  getInputs() {
+    return this.connection?.getInputs() || [];
+  }
+  /**
+   * Switch to a different output device
+   * @param {string|number} output - Device name, ID, or index
+   * @returns {Promise<void>}
+   */
+  async setOutput(E) {
+    await this.connection.connect(E), this.emit(o.OUTPUT_CHANGED, this.connection.getCurrentOutput());
+  }
+  /**
+   * Get current output device
+   * @returns {Object|null}
+   */
+  getCurrentOutput() {
+    return this.connection?.getCurrentOutput() || null;
+  }
+  /**
+   * Get current input device
+   * @returns {Object|null}
+   */
+  getCurrentInput() {
+    return this.connection?.getCurrentInput() || null;
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    for (const E of this.bindings.values())
+      E.destroy();
+    this.bindings.clear(), this.state.clear(), this.connection?.disconnect(), this.initialized = !1, this.emit(o.DESTROYED), this.removeAllListeners();
+  }
+  /**
+   * Handle incoming MIDI messages
+   * @private
+   */
+  _handleMIDIMessage(E) {
+    const [s, n, _] = E.data, A = s & 240, e = (s & 15) + 1;
+    if (s === 240) {
+      this.emit(o.SYSEX_RECV, {
+        data: Array.from(E.data),
+        timestamp: E.midiwire
+      });
+      return;
+    }
+    if (A === 176) {
+      const r = `${e}:${n}`;
+      this.state.set(r, _), this.emit(o.CC_RECV, {
+        cc: n,
+        value: _,
+        channel: e
+      });
+      return;
+    }
+    if (A === 144 && _ > 0) {
+      this.emit(o.NOTE_ON_RECV, {
+        note: n,
+        velocity: _,
+        channel: e
+      });
+      return;
+    }
+    if (A === 128 || A === 144 && _ === 0) {
+      this.emit(o.NOTE_OFF_RECV, {
+        note: n,
+        channel: e
+      });
+      return;
+    }
+    this.emit(o.MIDI_MSG, {
+      status: s,
+      data: [n, _],
+      channel: e,
+      timestamp: E.midiwire
+    });
+  }
+  /**
+   * Create a binding between an element and MIDI CC
+   * @private
+   */
+  _createBinding(E, s, n = {}) {
+    const {
+      min: _ = parseFloat(E.getAttribute("min")) || 0,
+      max: A = parseFloat(E.getAttribute("max")) || 127,
+      channel: e,
+      invert: r = !1,
+      onInput: T = void 0
+    } = s, { debounce: u = 0 } = n, i = {
+      ...s,
+      min: _,
+      max: A,
+      invert: r,
+      onInput: T
+    };
+    if (e !== void 0 && (i.channel = e), s.is14Bit) {
+      const { msb: h, lsb: U } = s, I = (R) => {
+        const F = parseFloat(R.target.value);
+        if (Number.isNaN(F)) return;
+        const { msb: y, lsb: v } = Z(F, _, A, r), G = e || this.options.channel;
+        this.sendCC(h, y, G), this.sendCC(U, v, G);
+      };
+      let K = null;
+      const L = u > 0 ? (R) => {
+        K && clearTimeout(K), K = setTimeout(() => {
+          I(R), K = null;
+        }, u);
+      } : I;
+      return E.addEventListener("input", L), E.addEventListener("change", L), {
+        element: E,
+        config: i,
+        handler: I,
+        destroy: () => {
+          K && clearTimeout(K), E.removeEventListener("input", L), E.removeEventListener("change", L);
+        }
+      };
+    }
+    const { cc: P } = s, l = (h) => {
+      const U = parseFloat(h.target.value);
+      if (Number.isNaN(U)) return;
+      const I = w(U, _, A, r), K = e === void 0 ? this.options.channel : e;
+      this.sendCC(P, I, K);
+    };
+    let S = null;
+    const N = u > 0 ? (h) => {
+      S && clearTimeout(S), S = setTimeout(() => {
+        l(h), S = null;
+      }, u);
+    } : l;
+    return E.addEventListener("input", N), E.addEventListener("change", N), {
+      element: E,
+      config: i,
+      handler: l,
+      destroy: () => {
+        S && clearTimeout(S), E.removeEventListener("input", N), E.removeEventListener("change", N);
+      }
+    };
+  }
+  /**
+   * Get current state as a patch object
+   * @param {string} [name] - Optional patch name
+   * @returns {Object} Patch object
+   */
+  getPatch(E = "Unnamed Patch") {
+    const s = {
+      name: E,
+      device: this.getCurrentOutput()?.name || null,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0",
+      channels: {},
+      settings: {}
+    };
+    for (const [n, _] of this.state.entries()) {
+      const [A, e] = n.split(":").map(Number);
+      s.channels[A] || (s.channels[A] = { ccs: {}, notes: {} }), s.channels[A].ccs[e] = _;
+    }
+    for (const [n, _] of this.bindings.entries()) {
+      const { config: A } = _;
+      if (A.cc) {
+        const e = `cc${A.cc}`;
+        s.settings[e] = {
+          min: A.min,
+          max: A.max,
+          invert: A.invert || !1,
+          is14Bit: A.is14Bit || !1,
+          label: n.getAttribute?.("data-midi-label") || null,
+          elementId: n.id || null
+        };
+      }
+    }
+    return s;
+  }
+  /**
+   * Apply a patch to the controller
+   * @param {PatchData} patch - Patch object
+   * @returns {Promise<void>}
+   */
+  async setPatch(E) {
+    if (!E || !E.channels)
+      throw new m("Invalid patch format", "patch");
+    const s = E.version || "1.0";
+    s === "1.0" ? await this._applyPatchV1(E) : (console.warn(`Unknown patch version: ${s}. Attempting to apply as v1.0`), await this._applyPatchV1(E)), this.emit(o.PATCH_LOADED, { patch: E });
+  }
+  /**
+   * Apply v1.0 patch format
+   * @private
+   * @param {PatchData} patch
+   */
+  async _applyPatchV1(E) {
+    for (const [s, n] of Object.entries(E.channels)) {
+      const _ = parseInt(s, 10);
+      if (n.ccs)
+        for (const [A, e] of Object.entries(n.ccs)) {
+          const r = parseInt(A, 10);
+          this.sendCC(r, e, _);
+        }
+      if (n.notes)
+        for (const [A, e] of Object.entries(n.notes)) {
+          const r = parseInt(A, 10);
+          e > 0 ? this.sendNoteOn(r, e, _) : this.sendNoteOff(r, _);
+        }
+    }
+    if (E.settings)
+      for (const [s, n] of Object.entries(E.settings))
+        for (const [_, A] of this.bindings.entries())
+          A.config.cc?.toString() === s.replace("cc", "") && (_.min !== void 0 && n.min !== void 0 && (_.min = String(n.min)), _.max !== void 0 && n.max !== void 0 && (_.max = String(n.max)));
+    for (const [s, n] of this.bindings.entries()) {
+      const { config: _ } = n;
+      if (_.cc !== void 0) {
+        const A = _.channel || this.options.channel, e = E.channels[A];
+        if (e?.ccs) {
+          const r = e.ccs[_.cc];
+          if (r !== void 0) {
+            const T = _.min !== void 0 ? _.min : parseFloat(s.getAttribute?.("min")) || 0, u = _.max !== void 0 ? _.max : parseFloat(s.getAttribute?.("max")) || 127, i = _.invert || !1;
+            let P;
+            i ? P = u - r / 127 * (u - T) : P = T + r / 127 * (u - T), _.onInput && typeof _.onInput == "function" ? _.onInput(P) : (s.value = P, s.dispatchEvent(new Event("input", { bubbles: !0 })));
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Save a patch to localStorage
+   * @param {string} name - Patch name
+   * @param {Object} [patch] - Optional patch object (will use getPatch() if not provided)
+   * @returns {string} Storage key used
+   */
+  savePatch(E, s = null) {
+    const n = s || this.getPatch(E), _ = `midiwire_patch_${E}`;
+    try {
+      return localStorage.setItem(_, JSON.stringify(n)), this.emit(o.PATCH_SAVED, { name: E, patch: n }), _;
+    } catch (A) {
+      throw console.error("Failed to save patch:", A), A;
+    }
+  }
+  /**
+   * Load a patch from localStorage
+   * @param {string} name - Patch name
+   * @returns {Object|null} Patch object or null if not found
+   */
+  loadPatch(E) {
+    const s = `midiwire_patch_${E}`;
+    try {
+      const n = localStorage.getItem(s);
+      if (!n)
+        return null;
+      const _ = JSON.parse(n);
+      return this.emit(o.PATCH_LOADED, { name: E, patch: _ }), _;
+    } catch (n) {
+      return console.error("Failed to load patch:", n), null;
+    }
+  }
+  /**
+   * Delete a patch from localStorage
+   * @param {string} name - Patch name
+   * @returns {boolean} Success
+   */
+  deletePatch(E) {
+    const s = `midiwire_patch_${E}`;
+    try {
+      return localStorage.removeItem(s), this.emit(o.PATCH_DELETED, { name: E }), !0;
+    } catch (n) {
+      return console.error("Failed to delete patch:", n), !1;
+    }
+  }
+  /**
+   * List all saved patches
+   * @returns {Array<Object>} Array of { name, patch }
+   */
+  listPatches() {
+    const E = [];
+    try {
+      for (let s = 0; s < localStorage.length; s++) {
+        const n = localStorage.key(s);
+        if (n?.startsWith("midiwire_patch_")) {
+          const _ = n.replace("midiwire_patch_", ""), A = this.loadPatch(_);
+          A && E.push({ name: _, patch: A });
+        }
+      }
+    } catch (s) {
+      console.error("Failed to list patches:", s);
+    }
+    return E.sort((s, n) => s.name.localeCompare(n.name));
+  }
+}
+class W {
+  /**
+   * @param {Object} options
+   * @param {MIDIController} options.midiController - The MIDIController instance
+   * @param {Function} options.onStatusUpdate - Callback for status updates (message, state)
+   * @param {Function} options.onConnectionUpdate - Callback when connection status changes
+   * @param {number} [options.channel=1] - Default MIDI channel
+   */
+  constructor(E = {}) {
+    this.midi = E.midiController || null, this.onStatusUpdate = E.onStatusUpdate || (() => {
+    }), this.onConnectionUpdate = E.onConnectionUpdate || (() => {
+    }), this.channel = E.channel || 1, this.currentDevice = null, this.isConnecting = !1;
+  }
+  /**
+   * Initialize the device manager with a MIDIController
+   * @param {MIDIController} midi
+   */
+  setMIDI(E) {
+    this.midi = E;
+  }
+  /**
+   * Set up device change event listeners
+   * @param {Function} [onDeviceListChange] - Optional callback when device list should be refreshed
+   */
+  setupDeviceListeners(E) {
+    this.midi?.connection && (this.midi.connection.on(d.OUTPUT_DEVICE_CONNECTED, ({ device: s }) => {
+      this.updateStatus(`Device connected: ${s.name}`, "connected"), E && E();
+    }), this.midi.connection.on(d.OUTPUT_DEVICE_DISCONNECTED, ({ device: s }) => {
+      this.updateStatus(`Device disconnected: ${s.name}`, "error"), this.currentDevice && s.name === this.currentDevice.name && (this.currentDevice = null, this.updateConnectionStatus()), E && E();
+    }));
+  }
+  /**
+   * Update status message
+   * @param {string} message
+   * @param {string} state
+   */
+  updateStatus(E, s = "") {
+    this.onStatusUpdate(E, s);
+  }
+  /**
+   * Update connection status
+   */
+  updateConnectionStatus() {
+    this.onConnectionUpdate(this.currentDevice, this.midi);
+  }
+  /**
+   * Get the current list of MIDI output devices
+   * @returns {Array<Object>} Array of device objects with id, name, manufacturer
+   */
+  getOutputDevices() {
+    return this.midi?.connection ? this.midi.connection.getOutputs() : [];
+  }
+  /**
+   * Check if a device is still connected
+   * @param {string} deviceName
+   * @returns {boolean}
+   */
+  isDeviceConnected(E) {
+    return this.midi?.connection ? this.midi.connection.getOutputs().some((n) => n.name === E) : !1;
+  }
+  /**
+   * Connect device selection events to the device manager
+   * @param {HTMLSelectElement} deviceSelectElement
+   * @param {Function} onConnect - Callback when device is connected (midi, device)
+   */
+  connectDeviceSelection(E, s) {
+    !E || !this.midi || E.addEventListener("change", async (n) => {
+      const _ = n.target.value;
+      if (!_) {
+        this.currentDevice && this.midi && (this.midi.connection.disconnect(), this.currentDevice = null, this.updateStatus("Disconnected"), this.updateConnectionStatus());
+        return;
+      }
+      if (!this.isConnecting) {
+        this.isConnecting = !0;
+        try {
+          await this.midi.setOutput(parseInt(_, 10)), this.currentDevice = this.midi.getCurrentOutput(), this.updateConnectionStatus(), s && await s(this.midi, this.currentDevice);
+        } catch (A) {
+          this.updateStatus(`Connection failed: ${A.message}`, "error");
+        } finally {
+          this.isConnecting = !1;
+        }
+      }
+    });
+  }
+  /**
+   * Connect channel selection events
+   * @param {HTMLSelectElement} channelSelectElement
+   */
+  connectChannelSelection(E) {
+    !E || !this.midi || E.addEventListener("change", (s) => {
+      this.midi && (this.midi.options.channel = parseInt(s.target.value, 10), this.updateConnectionStatus());
+    });
+  }
+  /**
+   * Populate a device select element with available MIDI output devices
+   * @param {HTMLSelectElement} selectElement
+   * @param {Function} [onChange] - Optional callback when selection should change
+   */
+  populateDeviceList(E, s) {
+    if (!E) return;
+    const n = this.getOutputDevices();
+    if (n.length > 0) {
+      if (E.innerHTML = '<option value="">Select a device</option>' + n.map((_, A) => `<option value="${A}">${_.name}</option>`).join(""), this.currentDevice) {
+        const _ = n.findIndex((A) => A.name === this.currentDevice.name);
+        _ !== -1 ? E.value = _.toString() : (E.value = "", this.currentDevice = null, this.updateConnectionStatus());
+      } else
+        E.value = "";
+      this.currentDevice || this.updateStatus("Select a MIDI device");
+    } else
+      E.innerHTML = '<option value="">No MIDI devices found</option>', this.updateStatus("No MIDI devices available", "error");
+    s && s();
+  }
+}
+class t {
+  // 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 = 60;
+  // MIDI note 60 = C3
+  static DEFAULT_OUTPUT_LEVEL = 99;
+  static DEFAULT_PITCH_EG_LEVEL = 50;
+  static DEFAULT_LFO_SPEED = 35;
+  static DEFAULT_LFO_PM_SENS = 3;
+  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;
+  // Offset for breakpoint display
+  /**
+   * Create a DX7Voice from raw 128-byte data
+   * @param {Array<number>|Uint8Array} data - 128 bytes of voice data
+   * @param {number} index - Voice index (0-31)
+   * @throws {DX7ValidationError} If data length is not exactly 128 bytes
+   */
+  constructor(E, s = 0) {
+    if (E.length !== t.PACKED_SIZE)
+      throw new c(
+        `Invalid voice data length: expected ${t.PACKED_SIZE} bytes, got ${E.length}`,
+        "length",
+        E.length
+      );
+    this.index = s, this.data = new Uint8Array(E), this.name = this._extractName();
+  }
+  /**
+   * Extract the voice name from the data (10 characters at offset 118)
+   * @private
+   */
+  _extractName() {
+    const E = this.data.subarray(
+      t.PACKED_NAME_START,
+      t.PACKED_NAME_START + t.NAME_LENGTH
+    );
+    return Array.from(E).map((n) => {
+      let _ = n & t.MASK_7BIT;
+      return _ === t.CHAR_YEN && (_ = t.CHAR_REPLACEMENT_Y), _ === t.CHAR_ARROW_RIGHT && (_ = t.CHAR_REPLACEMENT_GT), _ === t.CHAR_ARROW_LEFT && (_ = t.CHAR_REPLACEMENT_LT), (_ < t.CHAR_MIN_PRINTABLE || _ > t.CHAR_MAX_PRINTABLE) && (_ = t.CHAR_SPACE), String.fromCharCode(_);
+    }).join("").trim();
+  }
+  /**
+   * Get a raw parameter value from the packed data
+   * @param {number} offset - Byte offset in the voice data (0-127)
+   * @returns {number} Parameter value (0-127)
+   * @throws {DX7ValidationError} If offset is out of range
+   */
+  getParameter(E) {
+    if (E < 0 || E >= t.PACKED_SIZE)
+      throw new c(
+        `Parameter offset out of range: ${E} (must be 0-${t.PACKED_SIZE - 1})`,
+        "offset",
+        E
+      );
+    return this.data[E] & t.MASK_7BIT;
+  }
+  /**
+   * Get a parameter value from the unpacked 169-byte format
+   * @param {number} offset - Byte offset in the unpacked data (0-168)
+   * @returns {number} Parameter value (0-127)
+   * @throws {DX7ValidationError} If offset is out of range
+   */
+  getUnpackedParameter(E) {
+    if (E < 0 || E >= t.UNPACKED_SIZE)
+      throw new c(
+        `Unpacked parameter offset out of range: ${E} (must be 0-${t.UNPACKED_SIZE - 1})`,
+        "offset",
+        E
+      );
+    return this.unpack()[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(E, s) {
+    if (E < 0 || E >= t.PACKED_SIZE)
+      throw new c(
+        `Parameter offset out of range: ${E} (must be 0-${t.PACKED_SIZE - 1})`,
+        "offset",
+        E
+      );
+    this.data[E] = s & t.MASK_7BIT, 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
+   * This converts the packed 128-byte format to the full DX7 parameter set
+   * @returns {Uint8Array} 169 bytes of unpacked voice data (138 operator + 8 pitch EG + 13 global + 10 name = 169 bytes)
+   */
+  unpack() {
+    const E = this.data, s = new Uint8Array(t.UNPACKED_SIZE);
+    for (let A = 0; A < t.NUM_OPERATORS; A++) {
+      const e = (t.NUM_OPERATORS - 1 - A) * t.PACKED_OP_SIZE, r = A * t.UNPACKED_OP_SIZE;
+      s[r + t.UNPACKED_OP_EG_RATE_1] = E[e + t.PACKED_OP_EG_RATE_1] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_RATE_2] = E[e + t.PACKED_OP_EG_RATE_2] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_RATE_3] = E[e + t.PACKED_OP_EG_RATE_3] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_RATE_4] = E[e + t.PACKED_OP_EG_RATE_4] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_LEVEL_1] = E[e + t.PACKED_OP_EG_LEVEL_1] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_LEVEL_2] = E[e + t.PACKED_OP_EG_LEVEL_2] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_LEVEL_3] = E[e + t.PACKED_OP_EG_LEVEL_3] & t.MASK_7BIT, s[r + t.UNPACKED_OP_EG_LEVEL_4] = E[e + t.PACKED_OP_EG_LEVEL_4] & t.MASK_7BIT, s[r + t.UNPACKED_OP_BREAK_POINT] = E[e + t.PACKED_OP_BREAK_POINT] & t.MASK_7BIT, s[r + t.UNPACKED_OP_L_SCALE_DEPTH] = E[e + t.PACKED_OP_L_SCALE_DEPTH] & t.MASK_7BIT, s[r + t.UNPACKED_OP_R_SCALE_DEPTH] = E[e + t.PACKED_OP_R_SCALE_DEPTH] & t.MASK_7BIT;
+      const T = E[e + t.PACKED_OP_CURVES] & t.MASK_7BIT;
+      s[r + t.UNPACKED_OP_L_CURVE] = T & t.MASK_2BIT, s[r + t.UNPACKED_OP_R_CURVE] = T >> 2 & t.MASK_2BIT;
+      const u = E[e + t.PACKED_OP_RATE_SCALING] & t.MASK_7BIT;
+      s[r + t.UNPACKED_OP_RATE_SCALING] = u & t.MASK_3BIT, s[r + t.UNPACKED_OP_DETUNE] = u >> 3 & t.MASK_4BIT;
+      const i = E[e + t.PACKED_OP_MOD_SENS] & t.MASK_7BIT;
+      s[r + t.UNPACKED_OP_AMP_MOD_SENS] = i & t.MASK_2BIT, s[r + t.UNPACKED_OP_KEY_VEL_SENS] = i >> 2 & t.MASK_3BIT, s[r + t.UNPACKED_OP_OUTPUT_LEVEL] = E[e + t.PACKED_OP_OUTPUT_LEVEL] & t.MASK_7BIT;
+      const P = E[e + t.PACKED_OP_MODE_FREQ] & t.MASK_7BIT;
+      s[r + t.UNPACKED_OP_MODE] = P & t.MASK_1BIT, s[r + t.UNPACKED_OP_FREQ_COARSE] = P >> 1 & t.MASK_5BIT;
+      const l = E[e + t.PACKED_OP_DETUNE_FINE] & t.MASK_7BIT;
+      s[r + t.UNPACKED_OP_OSC_DETUNE] = l & t.MASK_3BIT, s[r + t.UNPACKED_OP_FREQ_FINE] = l >> 3 & t.MASK_4BIT;
+    }
+    s[t.UNPACKED_PITCH_EG_RATE_1] = E[t.PACKED_PITCH_EG_RATE_1] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_RATE_2] = E[t.PACKED_PITCH_EG_RATE_2] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_RATE_3] = E[t.PACKED_PITCH_EG_RATE_3] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_RATE_4] = E[t.PACKED_PITCH_EG_RATE_4] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_LEVEL_1] = E[t.PACKED_PITCH_EG_LEVEL_1] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_LEVEL_2] = E[t.PACKED_PITCH_EG_LEVEL_2] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_LEVEL_3] = E[t.PACKED_PITCH_EG_LEVEL_3] & t.MASK_7BIT, s[t.UNPACKED_PITCH_EG_LEVEL_4] = E[t.PACKED_PITCH_EG_LEVEL_4] & t.MASK_7BIT, s[t.UNPACKED_ALGORITHM] = E[t.OFFSET_ALGORITHM] & t.MASK_5BIT;
+    const n = E[t.OFFSET_FEEDBACK] & t.MASK_7BIT;
+    s[t.UNPACKED_FEEDBACK] = n & t.MASK_3BIT, s[t.UNPACKED_OSC_SYNC] = n >> 3 & t.MASK_1BIT, s[t.UNPACKED_LFO_SPEED] = E[t.OFFSET_LFO_SPEED] & t.MASK_7BIT, s[t.UNPACKED_LFO_DELAY] = E[t.OFFSET_LFO_DELAY] & t.MASK_7BIT, s[t.UNPACKED_LFO_PM_DEPTH] = E[t.OFFSET_LFO_PM_DEPTH] & t.MASK_7BIT, s[t.UNPACKED_LFO_AM_DEPTH] = E[t.OFFSET_LFO_AM_DEPTH] & t.MASK_7BIT;
+    const _ = E[t.OFFSET_LFO_SYNC_WAVE] & t.MASK_7BIT;
+    s[t.UNPACKED_LFO_KEY_SYNC] = _ & t.MASK_1BIT, s[t.UNPACKED_LFO_WAVE] = _ >> 1 & t.MASK_3BIT, s[t.UNPACKED_LFO_PM_SENS] = _ >> 4 & t.MASK_3BIT, s[t.UNPACKED_AMP_MOD_SENS] = E[t.OFFSET_AMP_MOD_SENS] & t.MASK_7BIT, s[t.UNPACKED_TRANSPOSE] = E[t.OFFSET_TRANSPOSE] & t.MASK_7BIT, s[t.UNPACKED_EG_BIAS_SENS] = E[t.OFFSET_EG_BIAS_SENS] & t.MASK_7BIT;
+    for (let A = 0; A < t.NAME_LENGTH; A++)
+      s[t.UNPACKED_NAME_START + A] = E[t.PACKED_NAME_START + A] & t.MASK_7BIT;
+    return s;
+  }
+  /**
+   * 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(E) {
+    if (E.length !== t.UNPACKED_SIZE)
+      throw new c(
+        `Invalid unpacked data length: expected ${t.UNPACKED_SIZE} bytes, got ${E.length}`,
+        "length",
+        E.length
+      );
+    const s = new Uint8Array(t.PACKED_SIZE);
+    for (let T = 0; T < t.NUM_OPERATORS; T++) {
+      const u = T * t.UNPACKED_OP_SIZE, i = (t.NUM_OPERATORS - 1 - T) * t.PACKED_OP_SIZE;
+      s[i + t.PACKED_OP_EG_RATE_1] = E[u + t.UNPACKED_OP_EG_RATE_1], s[i + t.PACKED_OP_EG_RATE_2] = E[u + t.UNPACKED_OP_EG_RATE_2], s[i + t.PACKED_OP_EG_RATE_3] = E[u + t.UNPACKED_OP_EG_RATE_3], s[i + t.PACKED_OP_EG_RATE_4] = E[u + t.UNPACKED_OP_EG_RATE_4], s[i + t.PACKED_OP_EG_LEVEL_1] = E[u + t.UNPACKED_OP_EG_LEVEL_1], s[i + t.PACKED_OP_EG_LEVEL_2] = E[u + t.UNPACKED_OP_EG_LEVEL_2], s[i + t.PACKED_OP_EG_LEVEL_3] = E[u + t.UNPACKED_OP_EG_LEVEL_3], s[i + t.PACKED_OP_EG_LEVEL_4] = E[u + t.UNPACKED_OP_EG_LEVEL_4], s[i + t.PACKED_OP_BREAK_POINT] = E[u + t.UNPACKED_OP_BREAK_POINT], s[i + t.PACKED_OP_L_SCALE_DEPTH] = E[u + t.UNPACKED_OP_L_SCALE_DEPTH], s[i + t.PACKED_OP_R_SCALE_DEPTH] = E[u + t.UNPACKED_OP_R_SCALE_DEPTH];
+      const P = E[u + t.UNPACKED_OP_L_CURVE] & t.MASK_2BIT, l = E[u + t.UNPACKED_OP_R_CURVE] & t.MASK_2BIT;
+      s[i + t.PACKED_OP_CURVES] = P | l << 2;
+      const S = E[u + t.UNPACKED_OP_RATE_SCALING] & t.MASK_3BIT, N = E[u + t.UNPACKED_OP_DETUNE] & t.MASK_4BIT;
+      s[i + t.PACKED_OP_RATE_SCALING] = S | N << 3;
+      const h = E[u + t.UNPACKED_OP_AMP_MOD_SENS] & t.MASK_2BIT, U = E[u + t.UNPACKED_OP_KEY_VEL_SENS] & t.MASK_3BIT;
+      s[i + t.PACKED_OP_MOD_SENS] = h | U << 2, s[i + t.PACKED_OP_OUTPUT_LEVEL] = E[u + t.UNPACKED_OP_OUTPUT_LEVEL];
+      const I = E[u + t.UNPACKED_OP_MODE] & t.MASK_1BIT, K = E[u + t.UNPACKED_OP_FREQ_COARSE] & t.MASK_5BIT;
+      s[i + t.PACKED_OP_MODE_FREQ] = I | K << 1;
+      const L = E[u + t.UNPACKED_OP_OSC_DETUNE] & t.MASK_3BIT, R = E[u + t.UNPACKED_OP_FREQ_FINE] & t.MASK_4BIT;
+      s[i + t.PACKED_OP_DETUNE_FINE] = L | R << 3;
+    }
+    s[t.PACKED_PITCH_EG_RATE_1] = E[t.UNPACKED_PITCH_EG_RATE_1], s[t.PACKED_PITCH_EG_RATE_2] = E[t.UNPACKED_PITCH_EG_RATE_2], s[t.PACKED_PITCH_EG_RATE_3] = E[t.UNPACKED_PITCH_EG_RATE_3], s[t.PACKED_PITCH_EG_RATE_4] = E[t.UNPACKED_PITCH_EG_RATE_4], s[t.PACKED_PITCH_EG_LEVEL_1] = E[t.UNPACKED_PITCH_EG_LEVEL_1], s[t.PACKED_PITCH_EG_LEVEL_2] = E[t.UNPACKED_PITCH_EG_LEVEL_2], s[t.PACKED_PITCH_EG_LEVEL_3] = E[t.UNPACKED_PITCH_EG_LEVEL_3], s[t.PACKED_PITCH_EG_LEVEL_4] = E[t.UNPACKED_PITCH_EG_LEVEL_4], s[t.OFFSET_ALGORITHM] = E[t.UNPACKED_ALGORITHM];
+    const n = E[t.UNPACKED_FEEDBACK] & t.MASK_3BIT, _ = E[t.UNPACKED_OSC_SYNC] & t.MASK_1BIT;
+    s[t.OFFSET_FEEDBACK] = n | _ << 3, s[t.OFFSET_LFO_SPEED] = E[t.UNPACKED_LFO_SPEED], s[t.OFFSET_LFO_DELAY] = E[t.UNPACKED_LFO_DELAY], s[t.OFFSET_LFO_PM_DEPTH] = E[t.UNPACKED_LFO_PM_DEPTH], s[t.OFFSET_LFO_AM_DEPTH] = E[t.UNPACKED_LFO_AM_DEPTH];
+    const A = E[t.UNPACKED_LFO_KEY_SYNC] & t.MASK_1BIT, e = E[t.UNPACKED_LFO_WAVE] & t.MASK_3BIT, r = E[t.UNPACKED_LFO_PM_SENS] & t.MASK_3BIT;
+    s[t.OFFSET_LFO_SYNC_WAVE] = A | e << 1 | r << 4, s[t.OFFSET_AMP_MOD_SENS] = E[t.UNPACKED_AMP_MOD_SENS], s[t.OFFSET_TRANSPOSE] = E[t.UNPACKED_TRANSPOSE], s[t.OFFSET_EG_BIAS_SENS] = E[t.UNPACKED_EG_BIAS_SENS];
+    for (let T = 0; T < t.NAME_LENGTH; T++)
+      s[t.PACKED_NAME_START + T] = E[t.UNPACKED_NAME_START + T];
+    return s;
+  }
+  /**
+   * Create a default/empty voice
+   * @param {number} index - Voice index
+   * @returns {DX7Voice}
+   */
+  static createDefault(E = 0) {
+    const s = new Uint8Array(t.UNPACKED_SIZE);
+    for (let A = 0; A < t.NUM_OPERATORS; A++) {
+      const e = A * t.UNPACKED_OP_SIZE;
+      s[e + t.UNPACKED_OP_EG_RATE_1] = t.DEFAULT_EG_RATE, s[e + t.UNPACKED_OP_EG_RATE_2] = t.DEFAULT_EG_RATE, s[e + t.UNPACKED_OP_EG_RATE_3] = t.DEFAULT_EG_RATE, s[e + t.UNPACKED_OP_EG_RATE_4] = t.DEFAULT_EG_RATE, s[e + t.UNPACKED_OP_EG_LEVEL_1] = t.DEFAULT_EG_LEVEL_MAX, s[e + t.UNPACKED_OP_EG_LEVEL_2] = t.DEFAULT_EG_LEVEL_MAX, s[e + t.UNPACKED_OP_EG_LEVEL_3] = t.DEFAULT_EG_LEVEL_MAX, s[e + t.UNPACKED_OP_EG_LEVEL_4] = t.DEFAULT_EG_LEVEL_MIN, s[e + t.UNPACKED_OP_BREAK_POINT] = t.DEFAULT_BREAK_POINT, s[e + t.UNPACKED_OP_L_SCALE_DEPTH] = 0, s[e + t.UNPACKED_OP_R_SCALE_DEPTH] = 0, s[e + t.UNPACKED_OP_L_CURVE] = 0, s[e + t.UNPACKED_OP_R_CURVE] = 0, s[e + t.UNPACKED_OP_RATE_SCALING] = 0, s[e + t.UNPACKED_OP_AMP_MOD_SENS] = 0, s[e + t.UNPACKED_OP_KEY_VEL_SENS] = 0, s[e + t.UNPACKED_OP_OUTPUT_LEVEL] = t.DEFAULT_OUTPUT_LEVEL, s[e + t.UNPACKED_OP_MODE] = 0, s[e + t.UNPACKED_OP_FREQ_COARSE] = 0, s[e + t.UNPACKED_OP_OSC_DETUNE] = 0, s[e + t.UNPACKED_OP_FREQ_FINE] = 0;
+    }
+    s[t.UNPACKED_PITCH_EG_RATE_1] = t.DEFAULT_EG_RATE, s[t.UNPACKED_PITCH_EG_RATE_2] = t.DEFAULT_EG_RATE, s[t.UNPACKED_PITCH_EG_RATE_3] = t.DEFAULT_EG_RATE, s[t.UNPACKED_PITCH_EG_RATE_4] = t.DEFAULT_EG_RATE, s[t.UNPACKED_PITCH_EG_LEVEL_1] = t.DEFAULT_PITCH_EG_LEVEL, s[t.UNPACKED_PITCH_EG_LEVEL_2] = t.DEFAULT_PITCH_EG_LEVEL, s[t.UNPACKED_PITCH_EG_LEVEL_3] = t.DEFAULT_PITCH_EG_LEVEL, s[t.UNPACKED_PITCH_EG_LEVEL_4] = t.DEFAULT_PITCH_EG_LEVEL, s[t.UNPACKED_ALGORITHM] = t.DEFAULT_ALGORITHM, s[t.UNPACKED_FEEDBACK] = t.DEFAULT_FEEDBACK, s[t.UNPACKED_OSC_SYNC] = 0, s[t.UNPACKED_LFO_SPEED] = t.DEFAULT_LFO_SPEED, s[t.UNPACKED_LFO_DELAY] = 0, s[t.UNPACKED_LFO_PM_DEPTH] = 0, s[t.UNPACKED_LFO_AM_DEPTH] = 0, s[t.UNPACKED_LFO_KEY_SYNC] = 0, s[t.UNPACKED_LFO_WAVE] = 0, s[t.UNPACKED_LFO_PM_SENS] = t.DEFAULT_LFO_PM_SENS, s[t.UNPACKED_AMP_MOD_SENS] = 0, s[t.UNPACKED_TRANSPOSE] = t.TRANSPOSE_CENTER, s[t.UNPACKED_EG_BIAS_SENS] = 0;
+    const n = "Init Voice";
+    for (let A = 0; A < t.NAME_LENGTH; A++)
+      s[t.UNPACKED_NAME_START + A] = A < n.length ? n.charCodeAt(A) : t.CHAR_SPACE;
+    const _ = t.pack(s);
+    return new t(_, E);
+  }
+  /**
+   * Create a voice from unpacked 169-byte data
+   * @param {Array<number>|Uint8Array} unpacked - 169 bytes of unpacked data (159 parameters + 10 name bytes)
+   * @param {number} index - Voice index
+   * @returns {DX7Voice}
+   */
+  static fromUnpacked(E, s = 0) {
+    const n = t.pack(E);
+    return new t(n, s);
+  }
+  /**
+   * Load a DX7 voice from a single voice SYX file
+   * @param {File|Blob} file - SYX file (single voice in VCED format)
+   * @returns {Promise<DX7Voice>}
+   * @throws {DX7ParseError} If file has invalid VCED header
+   * @throws {Error} If file cannot be read (FileReader error)
+   */
+  static async fromFile(E) {
+    return new Promise((s, n) => {
+      const _ = new FileReader();
+      _.onload = (A) => {
+        try {
+          const e = new Uint8Array(A.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 D("Invalid VCED header", "header", 0);
+          const r = e.subarray(
+            t.VCED_HEADER_SIZE,
+            t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE
+          ), T = e[t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE], u = C._calculateChecksum(r, t.VCED_DATA_SIZE);
+          T !== u && console.warn(
+            `DX7 VCED checksum mismatch (expected ${u.toString(16)}, got ${T.toString(16)}). This is common with vintage SysEx files.`
+          );
+          const i = new Uint8Array(t.UNPACKED_SIZE);
+          let P = 0;
+          for (let S = 0; S < t.NUM_OPERATORS; S++) {
+            const N = (t.NUM_OPERATORS - 1 - S) * t.UNPACKED_OP_SIZE;
+            i[N + t.UNPACKED_OP_EG_RATE_1] = r[P++], i[N + t.UNPACKED_OP_EG_RATE_2] = r[P++], i[N + t.UNPACKED_OP_EG_RATE_3] = r[P++], i[N + t.UNPACKED_OP_EG_RATE_4] = r[P++], i[N + t.UNPACKED_OP_EG_LEVEL_1] = r[P++], i[N + t.UNPACKED_OP_EG_LEVEL_2] = r[P++], i[N + t.UNPACKED_OP_EG_LEVEL_3] = r[P++], i[N + t.UNPACKED_OP_EG_LEVEL_4] = r[P++], i[N + t.UNPACKED_OP_BREAK_POINT] = r[P++], i[N + t.UNPACKED_OP_L_SCALE_DEPTH] = r[P++], i[N + t.UNPACKED_OP_R_SCALE_DEPTH] = r[P++], i[N + t.UNPACKED_OP_L_CURVE] = r[P++], i[N + t.UNPACKED_OP_R_CURVE] = r[P++], i[N + t.UNPACKED_OP_RATE_SCALING] = r[P++], i[N + t.UNPACKED_OP_DETUNE] = r[P++];
+            const h = r[P++];
+            i[N + t.UNPACKED_OP_AMP_MOD_SENS] = h & t.MASK_2BIT, i[N + t.UNPACKED_OP_KEY_VEL_SENS] = h >> 2 & t.MASK_3BIT, i[N + t.UNPACKED_OP_OUTPUT_LEVEL] = r[P++], i[N + t.UNPACKED_OP_MODE] = r[P++], i[N + t.UNPACKED_OP_FREQ_COARSE] = r[P++], i[N + t.UNPACKED_OP_FREQ_FINE] = r[P++], i[N + t.UNPACKED_OP_OSC_DETUNE] = r[P++];
+          }
+          i[t.UNPACKED_PITCH_EG_RATE_1] = r[P++], i[t.UNPACKED_PITCH_EG_RATE_2] = r[P++], i[t.UNPACKED_PITCH_EG_RATE_3] = r[P++], i[t.UNPACKED_PITCH_EG_RATE_4] = r[P++], i[t.UNPACKED_PITCH_EG_LEVEL_1] = r[P++], i[t.UNPACKED_PITCH_EG_LEVEL_2] = r[P++], i[t.UNPACKED_PITCH_EG_LEVEL_3] = r[P++], i[t.UNPACKED_PITCH_EG_LEVEL_4] = r[P++], i[t.UNPACKED_ALGORITHM] = r[P++], i[t.UNPACKED_FEEDBACK] = r[P++], i[t.UNPACKED_OSC_SYNC] = r[P++], i[t.UNPACKED_LFO_SPEED] = r[P++], i[t.UNPACKED_LFO_DELAY] = r[P++], i[t.UNPACKED_LFO_PM_DEPTH] = r[P++], i[t.UNPACKED_LFO_AM_DEPTH] = r[P++], i[t.UNPACKED_LFO_KEY_SYNC] = r[P++], i[t.UNPACKED_LFO_WAVE] = r[P++], i[t.UNPACKED_LFO_PM_SENS] = r[P++], i[t.UNPACKED_TRANSPOSE] = r[P++];
+          for (let S = 0; S < t.NAME_LENGTH; S++)
+            i[t.UNPACKED_NAME_START + S] = r[P++];
+          const l = t.pack(i);
+          s(new t(l, 0));
+        } catch (e) {
+          n(e);
+        }
+      }, _.onerror = () => n(new Error("Failed to read file")), _.readAsArrayBuffer(E);
+    });
+  }
+  /**
+   * Export voice to DX7 single voice SysEx format (VCED format)
+   * This is useful for synths that only support single voice dumps (e.g., KORG Volca FM)
+   * Converts from 169-byte unpacked format to 155-byte VCED format
+   * @returns {Uint8Array} Single voice SysEx data (163 bytes)
+   */
+  toSysEx() {
+    const E = this.unpack(), s = new Uint8Array(t.VCED_SIZE);
+    let n = 0;
+    s[n++] = t.VCED_SYSEX_START, s[n++] = t.VCED_YAMAHA_ID, s[n++] = t.VCED_SUB_STATUS, s[n++] = t.VCED_FORMAT_SINGLE, s[n++] = t.VCED_BYTE_COUNT_MSB, s[n++] = t.VCED_BYTE_COUNT_LSB;
+    for (let A = t.NUM_OPERATORS - 1; A >= 0; A--) {
+      const e = A * t.UNPACKED_OP_SIZE;
+      s[n++] = E[e + t.UNPACKED_OP_EG_RATE_1], s[n++] = E[e + t.UNPACKED_OP_EG_RATE_2], s[n++] = E[e + t.UNPACKED_OP_EG_RATE_3], s[n++] = E[e + t.UNPACKED_OP_EG_RATE_4], s[n++] = E[e + t.UNPACKED_OP_EG_LEVEL_1], s[n++] = E[e + t.UNPACKED_OP_EG_LEVEL_2], s[n++] = E[e + t.UNPACKED_OP_EG_LEVEL_3], s[n++] = E[e + t.UNPACKED_OP_EG_LEVEL_4], s[n++] = E[e + t.UNPACKED_OP_BREAK_POINT], s[n++] = E[e + t.UNPACKED_OP_L_SCALE_DEPTH], s[n++] = E[e + t.UNPACKED_OP_R_SCALE_DEPTH], s[n++] = E[e + t.UNPACKED_OP_L_CURVE], s[n++] = E[e + t.UNPACKED_OP_R_CURVE], s[n++] = E[e + t.UNPACKED_OP_RATE_SCALING], s[n++] = E[e + t.UNPACKED_OP_DETUNE];
+      const r = E[e + t.UNPACKED_OP_AMP_MOD_SENS] & t.MASK_2BIT, T = E[e + t.UNPACKED_OP_KEY_VEL_SENS] & t.MASK_3BIT;
+      s[n++] = r | T << 2, s[n++] = E[e + t.UNPACKED_OP_OUTPUT_LEVEL], s[n++] = E[e + t.UNPACKED_OP_MODE], s[n++] = E[e + t.UNPACKED_OP_FREQ_COARSE], s[n++] = E[e + t.UNPACKED_OP_OSC_DETUNE], s[n++] = E[e + t.UNPACKED_OP_FREQ_FINE];
+    }
+    s[n++] = E[t.UNPACKED_PITCH_EG_RATE_1], s[n++] = E[t.UNPACKED_PITCH_EG_RATE_2], s[n++] = E[t.UNPACKED_PITCH_EG_RATE_3], s[n++] = E[t.UNPACKED_PITCH_EG_RATE_4], s[n++] = E[t.UNPACKED_PITCH_EG_LEVEL_1], s[n++] = E[t.UNPACKED_PITCH_EG_LEVEL_2], s[n++] = E[t.UNPACKED_PITCH_EG_LEVEL_3], s[n++] = E[t.UNPACKED_PITCH_EG_LEVEL_4], s[n++] = E[t.UNPACKED_ALGORITHM], s[n++] = E[t.UNPACKED_FEEDBACK], s[n++] = E[t.UNPACKED_OSC_SYNC], s[n++] = E[t.UNPACKED_LFO_SPEED], s[n++] = E[t.UNPACKED_LFO_DELAY], s[n++] = E[t.UNPACKED_LFO_PM_DEPTH], s[n++] = E[t.UNPACKED_LFO_AM_DEPTH], s[n++] = E[t.UNPACKED_LFO_KEY_SYNC], s[n++] = E[t.UNPACKED_LFO_WAVE], s[n++] = E[t.UNPACKED_LFO_PM_SENS], s[n++] = E[t.UNPACKED_TRANSPOSE];
+    for (let A = 0; A < t.NAME_LENGTH; A++)
+      s[n++] = E[t.UNPACKED_NAME_START + A];
+    const _ = s.subarray(
+      t.VCED_HEADER_SIZE,
+      t.VCED_HEADER_SIZE + t.VCED_DATA_SIZE
+    );
+    return s[n++] = C._calculateChecksum(_, t.VCED_DATA_SIZE), s[n++] = t.VCED_SYSEX_END, s;
+  }
+  /**
+   * Convert voice to JSON format
+   * @returns {object} Voice data in JSON format
+   */
+  toJSON() {
+    const E = this.unpack(), s = [], n = (e) => ["-LN", "-EX", "+EX", "+LN"][e] || "UNKNOWN", _ = (e) => ["TRIANGLE", "SAW DOWN", "SAW UP", "SQUARE", "SINE", "SAMPLE & HOLD"][e] || "UNKNOWN", A = (e) => {
+      const r = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], T = Math.floor(e / 12) + t.MIDI_OCTAVE_OFFSET;
+      return `${r[e % 12]}${T}`;
+    };
+    for (let e = 0; e < t.NUM_OPERATORS; e++) {
+      const r = e * t.UNPACKED_OP_SIZE, T = E[r + t.UNPACKED_OP_MODE] === 0 ? "RATIO" : "FIXED";
+      s.push({
+        id: e + 1,
+        osc: {
+          detune: E[r + t.UNPACKED_OP_OSC_DETUNE],
+          freq: {
+            coarse: E[r + t.UNPACKED_OP_FREQ_COARSE],
+            fine: E[r + t.UNPACKED_OP_FREQ_FINE],
+            mode: T
+          }
+        },
+        eg: {
+          rates: [
+            E[r + t.UNPACKED_OP_EG_RATE_1],
+            E[r + t.UNPACKED_OP_EG_RATE_2],
+            E[r + t.UNPACKED_OP_EG_RATE_3],
+            E[r + t.UNPACKED_OP_EG_RATE_4]
+          ],
+          levels: [
+            E[r + t.UNPACKED_OP_EG_LEVEL_1],
+            E[r + t.UNPACKED_OP_EG_LEVEL_2],
+            E[r + t.UNPACKED_OP_EG_LEVEL_3],
+            E[r + t.UNPACKED_OP_EG_LEVEL_4]
+          ]
+        },
+        key: {
+          velocity: E[r + t.UNPACKED_OP_KEY_VEL_SENS],
+          scaling: E[r + t.UNPACKED_OP_RATE_SCALING],
+          breakPoint: A(
+            E[r + t.UNPACKED_OP_BREAK_POINT] + t.MIDI_BREAK_POINT_OFFSET
+          )
+        },
+        output: {
+          level: E[r + t.UNPACKED_OP_OUTPUT_LEVEL],
+          ampModSens: E[r + t.UNPACKED_OP_AMP_MOD_SENS]
+        },
+        scale: {
+          left: {
+            depth: E[r + t.UNPACKED_OP_L_SCALE_DEPTH],
+            curve: n(E[r + t.UNPACKED_OP_L_CURVE])
+          },
+          right: {
+            depth: E[r + t.UNPACKED_OP_R_SCALE_DEPTH],
+            curve: n(E[r + t.UNPACKED_OP_R_CURVE])
+          }
+        }
+      });
+    }
+    return {
+      name: this.name || "(Empty)",
+      operators: s,
+      pitchEG: {
+        rates: [
+          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: [
+          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: 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: _(E[t.UNPACKED_LFO_WAVE])
+      },
+      global: {
+        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 C {
+  // 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 = [
+    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
+  ];
+  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;
+  /**
+   * Create a DX7Bank
+   * @param {Array<number>|ArrayBuffer|Uint8Array} data - Bank SYX data (optional)
+   * @param {string} name - Optional bank name (e.g., filename)
+   */
+  constructor(E, s = "") {
+    if (this.voices = new Array(C.NUM_VOICES), this.name = s, E)
+      this._load(E);
+    else
+      for (let n = 0; n < C.NUM_VOICES; n++)
+        this.voices[n] = t.createDefault(n);
+  }
+  /**
+   * Calculate DX7 SysEx checksum
+   * @private
+   * @param {Uint8Array} data - Data to checksum
+   * @param {number} size - Number of bytes
+   * @returns {number} Checksum byte
+   */
+  static _calculateChecksum(E, s) {
+    let n = 0;
+    for (let _ = 0; _ < s; _++)
+      n += E[_];
+    return C.CHECKSUM_MODULO - n % C.CHECKSUM_MODULO & C.MASK_7BIT;
+  }
+  /**
+   * Load and validate bank data
+   * @private
+   * @param {Array<number>|ArrayBuffer|Uint8Array} data
+   */
+  _load(E) {
+    const s = E instanceof Uint8Array ? E : new Uint8Array(E);
+    let n, _ = 0;
+    if (s[0] === C.SYSEX_START) {
+      const e = s.subarray(0, C.SYSEX_HEADER_SIZE), r = C.SYSEX_HEADER;
+      for (let T = 0; T < C.SYSEX_HEADER_SIZE; T++)
+        if (e[T] !== r[T])
+          throw new D(
+            `Invalid SysEx header at position ${T}: expected ${r[T].toString(16)}, got ${e[T].toString(16)}`,
+            "header",
+            T
+          );
+      n = s.subarray(
+        C.SYSEX_HEADER_SIZE,
+        C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE
+      ), _ = C.SYSEX_HEADER_SIZE;
+    } else if (s.length === C.VOICE_DATA_SIZE)
+      n = s;
+    else
+      throw new c(
+        `Invalid data length: expected ${C.VOICE_DATA_SIZE} or ${C.SYSEX_SIZE} bytes, got ${s.length}`,
+        "length",
+        s.length
+      );
+    if (n.length !== C.VOICE_DATA_SIZE)
+      throw new c(
+        `Invalid voice data length: expected ${C.VOICE_DATA_SIZE} bytes, got ${n.length}`,
+        "length",
+        n.length
+      );
+    const A = C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE;
+    if (_ > 0 && s.length >= A + 1) {
+      const e = s[A], r = C._calculateChecksum(n, C.VOICE_DATA_SIZE);
+      e !== r && console.warn(
+        `DX7 checksum mismatch (expected ${r.toString(16)}, got ${e.toString(16)}). This is common with vintage SysEx files and the data is likely still valid.`
+      );
+    }
+    this.voices = new Array(C.NUM_VOICES);
+    for (let e = 0; e < C.NUM_VOICES; e++) {
+      const r = e * C.VOICE_SIZE, T = n.subarray(r, r + C.VOICE_SIZE);
+      this.voices[e] = new t(T, e);
+    }
+  }
+  /**
+   * Replace a voice at the specified index
+   * @param {number} index - Voice index (0-31)
+   * @param {DX7Voice} voice - Voice to insert
+   * @throws {DX7ValidationError} If index is out of range
+   */
+  replaceVoice(E, s) {
+    if (E < 0 || E >= C.NUM_VOICES)
+      throw new c(`Invalid voice index: ${E}`, "index", E);
+    const n = new Uint8Array(s.data);
+    this.voices[E] = new t(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(E) {
+    for (let s = 0; s < this.voices.length; s++) {
+      const n = this.voices[s];
+      if (n.name === "" || n.name === "Init Voice")
+        return this.replaceVoice(s, E), s;
+    }
+    return -1;
+  }
+  /**
+   * Get all voices in the bank
+   * @returns {DX7Voice[]}
+   */
+  getVoices() {
+    return this.voices;
+  }
+  /**
+   * Get a specific voice by index
+   * @param {number} index - Voice index (0-31)
+   * @returns {DX7Voice|null}
+   */
+  getVoice(E) {
+    return E < 0 || E >= this.voices.length ? null : this.voices[E];
+  }
+  /**
+   * Get all voice names
+   * @returns {string[]}
+   */
+  getVoiceNames() {
+    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(E) {
+    const s = E.toLowerCase();
+    return this.voices.find((n) => n.name.toLowerCase().includes(s)) || null;
+  }
+  /**
+   * Load a DX7 bank from a file
+   * @param {File|Blob} file - SYX file to load
+   * @returns {Promise<DX7Bank>}
+   * @throws {DX7ParseError} If file is a single voice file
+   * @throws {DX7ValidationError} If data is not valid DX7 SYX format
+   * @throws {Error} If file cannot be read (FileReader error)
+   */
+  static async fromFile(E) {
+    return new Promise((s, n) => {
+      const _ = new FileReader();
+      _.onload = async (A) => {
+        try {
+          const e = E.name || "", r = new Uint8Array(A.target.result);
+          if (r[0] === C.SYSEX_START && r[3] === t.VCED_FORMAT_SINGLE)
+            n(
+              new D(
+                "This is a single voice file. Use DX7Voice.fromFile() instead.",
+                "format",
+                3
+              )
+            );
+          else {
+            const T = e.replace(/\.[^/.]+$/, ""), u = new C(A.target.result, T);
+            s(u);
+          }
+        } catch (e) {
+          n(e);
+        }
+      }, _.onerror = () => n(new Error("Failed to read file")), _.readAsArrayBuffer(E);
+    });
+  }
+  /**
+   * Export bank to SysEx format
+   * @returns {Uint8Array} Full SysEx data (4104 bytes)
+   */
+  toSysEx() {
+    const E = new Uint8Array(C.SYSEX_SIZE);
+    let s = 0;
+    C.SYSEX_HEADER.forEach((_) => {
+      E[s++] = _;
+    });
+    for (const _ of this.voices)
+      for (let A = 0; A < C.VOICE_SIZE; A++)
+        E[s++] = _.data[A];
+    const n = E.subarray(
+      C.SYSEX_HEADER_SIZE,
+      C.SYSEX_HEADER_SIZE + C.VOICE_DATA_SIZE
+    );
+    return E[s++] = C._calculateChecksum(n, C.VOICE_DATA_SIZE), E[s++] = C.SYSEX_END, E;
+  }
+  /**
+   * Convert bank to JSON format
+   * @returns {object} Bank data in JSON format
+   */
+  toJSON() {
+    const E = this.voices.map((s, n) => {
+      const _ = s.toJSON();
+      return {
+        index: n + 1,
+        ..._
+      };
+    });
+    return {
+      version: "1.0",
+      name: this.name || "",
+      voices: E
+    };
+  }
+}
+function Et(a) {
+  return a[0] !== 240 || a[a.length - 1] !== 247 ? null : {
+    manufacturerId: a[1],
+    payload: a.slice(2, -1),
+    raw: a
+  };
+}
+function st(a, E) {
+  return [240, a, ...E, 247];
+}
+function nt(a) {
+  return a.length >= 2 && a[0] === 240 && a[a.length - 1] === 247;
+}
+function _t(a) {
+  const E = [];
+  for (let s = 0; s < a.length; s += 7) {
+    const n = a.slice(s, s + 7);
+    let _ = 0;
+    const A = [];
+    for (let e = 0; e < n.length; e++) {
+      const r = n[e];
+      r & 128 && (_ |= 1 << e), A.push(r & 127);
+    }
+    E.push(_, ...A);
+  }
+  return E;
+}
+function et(a) {
+  const E = [];
+  for (let s = 0; s < a.length; s += 8) {
+    const n = a[s], _ = Math.min(7, a.length - s - 1);
+    for (let A = 0; A < _; A++) {
+      let e = a[s + 1 + A];
+      n & 1 << A && (e |= 128), E.push(e);
+    }
+  }
+  return E;
+}
+function rt(a) {
+  return Number.isInteger(a) && a >= 1 && a <= 16;
+}
+function At(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 127;
+}
+function at(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 31;
+}
+function it(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 127;
+}
+function Pt(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 127;
+}
+function Ct(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 127;
+}
+function Tt(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 127;
+}
+function ut(a) {
+  return Number.isInteger(a) && a >= 0 && a <= 16383;
+}
+function Nt(a, E) {
+  return Number.isInteger(a) && a >= 0 && a <= 127 && Number.isInteger(E) && E >= 0 && E <= 127;
+}
+async function q(a = {}) {
+  const E = new z(a);
+  await E.initialize();
+  const s = a.selector || "[data-midi-cc]";
+  {
+    const n = new B(E, s);
+    n.bindAll(), a.watchDOM && n.enableAutoBinding(), E._binder = n;
+  }
+  return E;
+}
+async function St(a = {}) {
+  const {
+    onStatusUpdate: E,
+    onConnectionUpdate: s,
+    channel: n,
+    output: _,
+    sysex: A,
+    onReady: e,
+    onError: r,
+    selector: T,
+    watchDOM: u,
+    ...i
+  } = a, l = await q({
+    autoConnect: !1,
+    sysex: A,
+    channel: n || 1,
+    selector: T || "[data-midi-cc]",
+    watchDOM: u,
+    onError: r,
+    ...i
+  }), S = new W({
+    midiController: l,
+    onStatusUpdate: E || (() => {
+    }),
+    onConnectionUpdate: s || (() => {
+    }),
+    channel: n || 1
+  });
+  if (_)
+    try {
+      await l.setOutput(_), S.currentDevice = l.getCurrentOutput(), S.updateConnectionStatus();
+    } catch (N) {
+      r ? r(N) : console.error("Failed to connect to MIDI device:", N.message);
+    }
+  return e && e(l, S), S;
+}
+export {
+  d as CONN,
+  d as CONNECTION_EVENTS,
+  o as CONTROLLER_EVENTS,
+  o as CTRL,
+  C as DX7Bank,
+  H as DX7Error,
+  D as DX7ParseError,
+  c as DX7ValidationError,
+  t as DX7Voice,
+  B as DataAttributeBinder,
+  b as EventEmitter,
+  p as MIDIAccessError,
+  $ as MIDIConnection,
+  g as MIDIConnectionError,
+  z as MIDIController,
+  f as MIDIDeviceError,
+  W as MIDIDeviceManager,
+  M as MIDIError,
+  m as MIDIValidationError,
+  O as clamp,
+  q as createMIDIController,
+  St as createMIDIDeviceManager,
+  st as createSysEx,
+  Y as decode14BitValue,
+  et as decode7Bit,
+  tt as denormalize14BitValue,
+  Q as denormalizeValue,
+  x as encode14BitValue,
+  _t as encode7Bit,
+  k as frequencyToNote,
+  X as getCCName,
+  nt as isSysEx,
+  at as isValid14BitCC,
+  At as isValidCC,
+  rt as isValidChannel,
+  it as isValidMIDIValue,
+  Pt as isValidNote,
+  ut as isValidPitchBend,
+  Nt as isValidPitchBendBytes,
+  Tt as isValidProgramChange,
+  Ct as isValidVelocity,
+  Z as normalize14BitValue,
+  w as normalizeValue,
+  j as noteNameToNumber,
+  J as noteNumberToName,
+  V as noteToFrequency,
+  Et as parseSysEx
+};