@al8b/audio 0.1.0

package/dist/index.mjs

@@ -0,0 +1,888 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/core/audio-core.ts
+import { APIErrorCode, reportRuntimeError } from "@al8b/diagnostics";
+
+// src/constants.ts
+var A4_FREQUENCY = 440;
+var SEMITONE_RATIO = 2 ** (1 / 12);
+var A4_MIDI_NOTE = 69;
+
+// src/devices/beeper.ts
+var Beeper = class {
+  static {
+    __name(this, "Beeper");
+  }
+  audio;
+  notes = {};
+  plainNotes = {};
+  currentOctave = 5;
+  currentDuration = 0.5;
+  currentVolume = 0.5;
+  currentSpan = 1;
+  currentWaveform = "square";
+  constructor(audio) {
+    this.audio = audio;
+    this.initializeNotes();
+  }
+  /**
+  * Initialize note mappings
+  */
+  initializeNotes() {
+    const noteNames = [
+      [
+        "C",
+        "DO"
+      ],
+      [
+        "C#",
+        "DO#",
+        "Db",
+        "REb"
+      ],
+      [
+        "D",
+        "RE"
+      ],
+      [
+        "D#",
+        "RE#",
+        "Eb",
+        "MIb"
+      ],
+      [
+        "E",
+        "MI"
+      ],
+      [
+        "F",
+        "FA"
+      ],
+      [
+        "F#",
+        "FA#",
+        "Gb",
+        "SOLb"
+      ],
+      [
+        "G",
+        "SOL"
+      ],
+      [
+        "G#",
+        "SOL#",
+        "Ab",
+        "LAb"
+      ],
+      [
+        "A",
+        "LA"
+      ],
+      [
+        "A#",
+        "LA#",
+        "Bb",
+        "SIb"
+      ],
+      [
+        "B",
+        "SI"
+      ]
+    ];
+    for (let i = 0; i <= 127; i++) {
+      this.notes[i] = i;
+      const oct = Math.floor(i / 12) - 1;
+      for (const n of noteNames[i % 12]) {
+        this.notes[n + oct] = i;
+      }
+      if (oct === -1) {
+        for (const n of noteNames[i % 12]) {
+          this.plainNotes[n] = i;
+        }
+      }
+    }
+  }
+  /**
+  * Parse and play beep sequence
+  */
+  beep(input) {
+    let status = "normal";
+    const sequence = [];
+    const loops = [];
+    let note;
+    const parsed = input.split(" ");
+    for (const t of parsed) {
+      if (t === "") continue;
+      switch (status) {
+        case "normal":
+          if (this.notes[t] !== void 0) {
+            note = this.notes[t];
+            this.currentOctave = Math.floor(note / 12);
+            sequence.push({
+              frequency: A4_FREQUENCY * SEMITONE_RATIO ** (note - A4_MIDI_NOTE),
+              volume: this.currentVolume,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if (this.plainNotes[t] !== void 0) {
+            note = this.plainNotes[t] + this.currentOctave * 12;
+            sequence.push({
+              frequency: A4_FREQUENCY * SEMITONE_RATIO ** (note - A4_MIDI_NOTE),
+              volume: this.currentVolume,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if ([
+            "square",
+            "sine",
+            "saw",
+            "noise"
+          ].includes(t)) {
+            this.currentWaveform = t;
+          } else if ([
+            "tempo",
+            "duration",
+            "volume",
+            "span",
+            "loop",
+            "to"
+          ].includes(t)) {
+            status = t;
+          } else if (t === "-") {
+            sequence.push({
+              frequency: A4_FREQUENCY,
+              volume: 0,
+              span: this.currentSpan,
+              duration: this.currentDuration,
+              waveform: this.currentWaveform
+            });
+          } else if (t === "end") {
+            if (loops.length > 0 && sequence.length > 0) {
+              sequence.push({
+                frequency: A4_FREQUENCY,
+                volume: 0,
+                span: this.currentSpan,
+                duration: 0,
+                waveform: this.currentWaveform
+              });
+              const lop = loops.splice(loops.length - 1, 1)[0];
+              sequence[sequence.length - 1].loopto = lop.start;
+              sequence[sequence.length - 1].repeats = lop.repeats;
+            }
+          }
+          break;
+        case "tempo": {
+          status = "normal";
+          const tempo = Number.parseFloat(t);
+          if (!Number.isNaN(tempo) && tempo > 0) {
+            this.currentDuration = 60 / tempo;
+          }
+          break;
+        }
+        case "duration": {
+          status = "normal";
+          const duration = Number.parseFloat(t);
+          if (!Number.isNaN(duration) && duration > 0) {
+            this.currentDuration = duration / 1e3;
+          }
+          break;
+        }
+        case "volume": {
+          status = "normal";
+          const volume = Number.parseFloat(t);
+          if (!Number.isNaN(volume)) {
+            this.currentVolume = volume / 100;
+          }
+          break;
+        }
+        case "span": {
+          status = "normal";
+          const span = Number.parseFloat(t);
+          if (!Number.isNaN(span)) {
+            this.currentSpan = span / 100;
+          }
+          break;
+        }
+        case "loop": {
+          status = "normal";
+          loops.push({
+            start: sequence.length
+          });
+          const repeats = Number.parseFloat(t);
+          if (!Number.isNaN(repeats)) {
+            loops[loops.length - 1].repeats = repeats;
+          }
+          break;
+        }
+        case "to":
+          status = "normal";
+          if (note !== void 0) {
+            let n;
+            if (this.notes[t] !== void 0) {
+              n = this.notes[t];
+            } else if (this.plainNotes[t] !== void 0) {
+              n = this.plainNotes[t] + this.currentOctave * 12;
+            }
+            if (n !== void 0 && n !== note) {
+              const step = n > note ? 1 : -1;
+              for (let i = note + step; step > 0 ? i <= n : i >= n; i += step) {
+                sequence.push({
+                  frequency: A4_FREQUENCY * SEMITONE_RATIO ** (i - A4_MIDI_NOTE),
+                  volume: this.currentVolume,
+                  span: this.currentSpan,
+                  duration: this.currentDuration,
+                  waveform: this.currentWaveform
+                });
+              }
+              note = n;
+            }
+          }
+          break;
+      }
+    }
+    if (loops.length > 0 && sequence.length > 0) {
+      const lop = loops.splice(loops.length - 1, 1)[0];
+      sequence.push({
+        frequency: A4_FREQUENCY,
+        volume: 0,
+        span: this.currentSpan,
+        duration: 0,
+        waveform: this.currentWaveform
+      });
+      sequence[sequence.length - 1].loopto = lop.start;
+      sequence[sequence.length - 1].repeats = lop.repeats;
+    }
+    this.audio.addBeeps(sequence);
+  }
+};
+
+// src/core/audio-worklet.ts
+var AUDIO_WORKLET_CODE = `
+class L8bAudioProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super();
+        this.beeps = [];
+        this.last = 0;
+        this.port.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.name === "cancel_beeps") {
+                this.beeps = [];
+            } else if (data.name === "beep") {
+                const seq = data.sequence;
+                // Link sequence notes together
+                for (let i = 0; i < seq.length; i++) {
+                    const note = seq[i];
+                    if (i > 0) {
+                        seq[i - 1].next = note;
+                    }
+                    // Resolve loopto index to actual note reference
+                    if (note.loopto != null) {
+                        note.loopto = seq[note.loopto];
+                    }
+                    // Initialize phase and time
+                    note.phase = 0;
+                    note.time = 0;
+                }
+                // Add first note to beeps queue
+                if (seq.length > 0) {
+                    this.beeps.push(seq[0]);
+                }
+            }
+        };
+    }
+
+    process(inputs, outputs, parameters) {
+        const output = outputs[0];
+        
+        for (let i = 0; i < output.length; i++) {
+            const channel = output[i];
+            
+            if (i > 0) {
+                // Copy first channel to other channels
+                for (let j = 0; j < channel.length; j++) {
+                    channel[j] = output[0][j];
+                }
+            } else {
+                // Generate audio for first channel
+                for (let j = 0; j < channel.length; j++) {
+                    let sig = 0;
+                    
+                    for (let k = this.beeps.length - 1; k >= 0; k--) {
+                        const b = this.beeps[k];
+                        let volume = b.volume;
+                        
+                        if (b.time / b.duration > b.span) {
+                            volume = 0;
+                        }
+                        
+                        // Generate waveform
+                        switch (b.waveform) {
+                            case "square":
+                                sig += b.phase > 0.5 ? volume : -volume;
+                                break;
+                            case "saw":
+                                sig += (b.phase * 2 - 1) * volume;
+                                break;
+                            case "noise":
+                                sig += (Math.random() * 2 - 1) * volume;
+                                break;
+                            default: // sine
+                                sig += Math.sin(b.phase * Math.PI * 2) * volume;
+                        }
+                        
+                        b.phase = (b.phase + b.increment) % 1;
+                        b.time += 1;
+                        
+                        if (b.time >= b.duration) {
+                            b.time = 0;
+                            
+                            if (b.loopto != null) {
+                                if (b.repeats != null && b.repeats > 0) {
+                                    if (b.loopcount == null) {
+                                        b.loopcount = 0;
+                                    }
+                                    b.loopcount++;
+                                    
+                                    if (b.loopcount >= b.repeats) {
+                                        b.loopcount = 0;
+                                        if (b.next != null) {
+                                            b.next.phase = b.phase;
+                                            this.beeps[k] = b.next;
+                                        } else {
+                                            this.beeps.splice(k, 1);
+                                        }
+                                    } else {
+                                        b.loopto.phase = b.phase;
+                                        this.beeps[k] = b.loopto;
+                                    }
+                                } else {
+                                    b.loopto.phase = b.phase;
+                                    this.beeps[k] = b.loopto;
+                                }
+                            } else if (b.next != null) {
+                                b.next.phase = b.phase;
+                                this.beeps[k] = b.next;
+                            } else {
+                                this.beeps.splice(k, 1);
+                            }
+                        }
+                    }
+                    
+                    this.last = this.last * 0.9 + sig * 0.1;
+                    channel[j] = this.last;
+                }
+            }
+        }
+        
+        return true;
+    }
+}
+
+registerProcessor("l8b-audio-processor", L8bAudioProcessor);
+`;
+
+// src/core/audio-core.ts
+var AudioCore = class {
+  static {
+    __name(this, "AudioCore");
+  }
+  context;
+  buffer = [];
+  playing = [];
+  wakeupList = [];
+  workletNode;
+  beeper;
+  runtime;
+  masterVolume = 1;
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.getContext();
+  }
+  /**
+  * Check if audio context is running
+  */
+  isStarted() {
+    return this.context.state === "running";
+  }
+  /**
+  * Add item to wakeup list (for mobile audio activation)
+  */
+  addToWakeUpList(item) {
+    this.wakeupList.push(item);
+  }
+  interfaceCache = null;
+  /**
+  * Set master volume (0-1). Applied as a multiplier to all sound/music playback.
+  */
+  setVolume(volume) {
+    this.masterVolume = Math.max(0, Math.min(1, volume));
+  }
+  /**
+  * Get current master volume (0-1)
+  */
+  getVolume() {
+    return this.masterVolume;
+  }
+  /**
+  * Get interface for game code
+  */
+  getInterface() {
+    if (this.interfaceCache) {
+      return this.interfaceCache;
+    }
+    this.interfaceCache = {
+      beep: /* @__PURE__ */ __name((sequence) => this.beep(sequence), "beep"),
+      cancelBeeps: /* @__PURE__ */ __name(() => this.cancelBeeps(), "cancelBeeps"),
+      playSound: /* @__PURE__ */ __name((sound, volume, pitch, pan, loopit) => this.playSound(sound, volume, pitch, pan, loopit), "playSound"),
+      playMusic: /* @__PURE__ */ __name((music, volume, loopit) => this.playMusic(music, volume, loopit), "playMusic"),
+      setVolume: /* @__PURE__ */ __name((volume) => this.setVolume(volume), "setVolume"),
+      getVolume: /* @__PURE__ */ __name(() => this.getVolume(), "getVolume"),
+      stopAll: /* @__PURE__ */ __name(() => this.stopAll(), "stopAll")
+    };
+    return this.interfaceCache;
+  }
+  /**
+  * Play sound effect
+  */
+  playSound(sound, volume = 1, pitch = 1, pan = 0, loopit = false) {
+    if (typeof sound === "string") {
+      const soundName = sound.replace(/\//g, "-");
+      const s = this.runtime.sounds[soundName];
+      if (!s) {
+        reportRuntimeError(this.runtime?.listener, APIErrorCode.E7013, {
+          soundName
+        });
+        return 0;
+      }
+      return s.play(volume * this.masterVolume, pitch, pan, loopit);
+    }
+    return 0;
+  }
+  /**
+  * Play music
+  */
+  playMusic(music, volume = 1, loopit = false) {
+    if (typeof music === "string") {
+      const musicName = music.replace(/\//g, "-");
+      const m = this.runtime.music[musicName];
+      if (!m) {
+        reportRuntimeError(this.runtime?.listener, APIErrorCode.E7014, {
+          musicName
+        });
+        return 0;
+      }
+      return m.play(volume * this.masterVolume, loopit);
+    }
+    return 0;
+  }
+  /**
+  * Get or create audio context (lazy initialization - created on first use)
+  * Note: Browser may suspend context until user interaction, which is handled automatically
+  */
+  getContext() {
+    if (!this.context) {
+      const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+      this.context = new AudioContextClass();
+      if (this.context.state !== "running") {
+        const activate = /* @__PURE__ */ __name(() => {
+          if (this.context && this.context.state !== "running") {
+            this.context.resume();
+            if (this.beeper) {
+              this.start();
+            }
+            for (const item of this.wakeupList) {
+              item.wakeUp();
+            }
+            document.body.removeEventListener("touchend", activate);
+            document.body.removeEventListener("mouseup", activate);
+            document.body.removeEventListener("click", activate);
+            document.body.removeEventListener("keydown", activate);
+          }
+        }, "activate");
+        document.body.addEventListener("touchend", activate, {
+          once: true
+        });
+        document.body.addEventListener("mouseup", activate, {
+          once: true
+        });
+        document.body.addEventListener("click", activate, {
+          once: true
+        });
+        document.body.addEventListener("keydown", activate, {
+          once: true
+        });
+      } else if (this.beeper) {
+        this.start();
+      }
+    }
+    return this.context;
+  }
+  /**
+  * Start audio processor
+  */
+  async start() {
+    if (this.workletNode) return;
+    try {
+      const blob = new Blob([
+        AUDIO_WORKLET_CODE
+      ], {
+        type: "application/javascript"
+      });
+      const url = URL.createObjectURL(blob);
+      await this.context.audioWorklet.addModule(url);
+      this.workletNode = new AudioWorkletNode(this.context, "l8b-audio-processor");
+      this.workletNode.connect(this.context.destination);
+      this.flushBuffer();
+    } catch (e) {
+      reportRuntimeError(this.runtime?.listener, APIErrorCode.E7012, {
+        error: String(e)
+      });
+    }
+  }
+  /**
+  * Flush buffered messages
+  */
+  flushBuffer() {
+    if (!this.workletNode) return;
+    while (this.buffer.length > 0) {
+      this.workletNode.port.postMessage(this.buffer.splice(0, 1)[0]);
+    }
+  }
+  /**
+  * Get or create beeper
+  */
+  getBeeper() {
+    if (!this.beeper) {
+      this.beeper = new Beeper(this);
+      if (this.context.state === "running") {
+        this.start();
+      }
+    }
+    return this.beeper;
+  }
+  /**
+  * Play beep sequence
+  */
+  beep(sequence) {
+    this.getBeeper().beep(sequence);
+  }
+  /**
+  * Add beeps to audio processor
+  */
+  addBeeps(beeps) {
+    for (const b of beeps) {
+      b.duration *= this.context.sampleRate;
+      b.increment = b.frequency / this.context.sampleRate;
+    }
+    if (this.workletNode) {
+      this.workletNode.port.postMessage(JSON.stringify({
+        name: "beep",
+        sequence: beeps
+      }));
+    } else {
+      this.buffer.push(JSON.stringify({
+        name: "beep",
+        sequence: beeps
+      }));
+    }
+  }
+  /**
+  * Cancel all beeps
+  */
+  cancelBeeps() {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage(JSON.stringify({
+        name: "cancel_beeps"
+      }));
+    } else {
+      this.buffer.push(JSON.stringify({
+        name: "cancel_beeps"
+      }));
+    }
+    this.stopAll();
+  }
+  /**
+  * Add playing sound/music to list
+  */
+  addPlaying(item) {
+    this.playing.push(item);
+  }
+  /**
+  * Remove playing sound/music from list
+  */
+  removePlaying(item) {
+    const index = this.playing.indexOf(item);
+    if (index >= 0) {
+      this.playing.splice(index, 1);
+    }
+  }
+  /**
+  * Stop all playing sounds/music
+  */
+  stopAll() {
+    for (const p of this.playing) {
+      try {
+        p.stop();
+      } catch (err) {
+        reportRuntimeError(this.runtime?.listener, APIErrorCode.E7016, {
+          error: String(err)
+        });
+      }
+    }
+    this.playing = [];
+  }
+};
+
+// src/devices/music.ts
+var Music = class {
+  static {
+    __name(this, "Music");
+  }
+  ready = 1;
+  name = "";
+  url;
+  tag;
+  playing = false;
+  audio;
+  constructor(audio, url) {
+    this.audio = audio;
+    this.url = url;
+    this.tag = new Audio(this.url);
+    this.ready = 1;
+  }
+  /**
+  * Play music with volume and loop (HTML5 Audio implementation)
+  */
+  play(volume = 1, loopit = false) {
+    this.playing = true;
+    this.tag.loop = !!loopit;
+    this.tag.volume = Math.max(0, Math.min(1, volume));
+    if (this.audio.isStarted()) {
+      this.tag.play();
+    } else {
+      this.audio.addToWakeUpList(this);
+    }
+    this.audio.addPlaying(this);
+    return {
+      play: /* @__PURE__ */ __name(() => {
+        return this.tag.play();
+      }, "play"),
+      stop: /* @__PURE__ */ __name(() => {
+        this.playing = false;
+        this.tag.pause();
+        this.audio.removePlaying(this);
+      }, "stop"),
+      setVolume: /* @__PURE__ */ __name((v) => {
+        this.tag.volume = Math.max(0, Math.min(1, v));
+      }, "setVolume"),
+      getPosition: /* @__PURE__ */ __name(() => {
+        return this.tag.currentTime;
+      }, "getPosition"),
+      getDuration: /* @__PURE__ */ __name(() => {
+        return this.tag.duration;
+      }, "getDuration"),
+      setPosition: /* @__PURE__ */ __name((pos) => {
+        this.tag.pause();
+        this.tag.currentTime = Math.max(0, Math.min(this.tag.duration, pos));
+        if (this.playing) {
+          this.tag.play();
+        }
+      }, "setPosition")
+    };
+  }
+  /**
+  * Wake up audio (for autoplay policy)
+  */
+  wakeUp() {
+    if (this.playing) {
+      this.tag.play();
+    }
+  }
+  /**
+  * Stop music
+  */
+  stop() {
+    this.playing = false;
+    this.tag.pause();
+    this.audio.removePlaying(this);
+  }
+};
+
+// src/devices/sound.ts
+import { APIErrorCode as APIErrorCode2, reportRuntimeError as reportRuntimeError2 } from "@al8b/diagnostics";
+var Sound = class _Sound {
+  static {
+    __name(this, "Sound");
+  }
+  ready = 0;
+  buffer;
+  name = "";
+  url;
+  audio;
+  constructor(audio, url) {
+    this.audio = audio;
+    if (url instanceof AudioBuffer) {
+      this.buffer = url;
+      this.url = "";
+      this.ready = 1;
+    } else {
+      this.url = url;
+      this.loadSound(url);
+    }
+  }
+  /**
+  * Load sound from URL
+  */
+  loadSound(url) {
+    const request = new XMLHttpRequest();
+    request.open("GET", url, true);
+    request.responseType = "arraybuffer";
+    request.onload = () => {
+      this.audio.context.decodeAudioData(request.response, (buffer) => {
+        this.buffer = buffer;
+        this.ready = 1;
+      }, (err) => {
+        reportRuntimeError2(this.audio?.runtime?.listener, APIErrorCode2.E7016, {
+          error: `Audio decoding failed: ${String(err)}`
+        });
+      });
+    };
+    request.onerror = () => {
+      reportRuntimeError2(this.audio?.runtime?.listener, APIErrorCode2.E7016, {
+        error: `Failed to load sound: ${url}`
+      });
+    };
+    request.send();
+  }
+  /**
+  * Play sound with volume, pitch, pan, and loop
+  */
+  play(volume = 1, pitch = 1, pan = 0, loopit = false) {
+    if (!this.buffer) return {
+      stop: /* @__PURE__ */ __name(() => {
+      }, "stop"),
+      finished: true
+    };
+    const context = this.audio.context;
+    const source = context.createBufferSource();
+    source.playbackRate.value = pitch;
+    source.buffer = this.buffer;
+    if (loopit) source.loop = true;
+    const gain = context.createGain();
+    gain.gain.value = volume;
+    const panner = context.createPanner();
+    panner.panningModel = "equalpower";
+    panner.setPan = (p) => {
+      panner.setPosition(p, 0, 1 - Math.abs(p));
+    };
+    panner.setPan(pan);
+    source.connect(gain);
+    gain.connect(panner);
+    panner.connect(context.destination);
+    source.start();
+    let playing = null;
+    if (loopit) {
+      playing = {
+        stop: /* @__PURE__ */ __name(() => {
+          source.stop();
+        }, "stop")
+      };
+      this.audio.addPlaying(playing);
+    }
+    const res = {
+      stop: /* @__PURE__ */ __name(() => {
+        source.stop();
+        if (playing) this.audio.removePlaying(playing);
+        return 1;
+      }, "stop"),
+      setVolume: /* @__PURE__ */ __name((v) => {
+        gain.gain.value = Math.max(0, Math.min(1, v));
+      }, "setVolume"),
+      setPitch: /* @__PURE__ */ __name((p) => {
+        source.playbackRate.value = Math.max(1e-3, Math.min(1e3, p));
+      }, "setPitch"),
+      setPan: /* @__PURE__ */ __name((p) => {
+        panner.setPan(Math.max(-1, Math.min(1, p)));
+      }, "setPan"),
+      getDuration: /* @__PURE__ */ __name(() => {
+        return source.buffer ? source.buffer.duration : 0;
+      }, "getDuration"),
+      finished: false
+    };
+    source.onended = () => {
+      res.finished = true;
+    };
+    return res;
+  }
+  /**
+  * Create MicroSound class for procedural sound generation
+  */
+  static createSoundClass(audiocore) {
+    return class MicroSound {
+      static {
+        __name(this, "MicroSound");
+      }
+      static classname = "Sound";
+      channels;
+      length;
+      sampleRate;
+      sound;
+      buffer;
+      constructor(channels, length, sampleRate = 44100) {
+        channels = channels === 1 ? 1 : 2;
+        if (!(length > 1 && length < 44100 * 1e3)) {
+          length = 44100;
+        }
+        if (!(sampleRate >= 8e3 && sampleRate <= 96e3)) {
+          sampleRate = 44100;
+        }
+        this.channels = channels;
+        this.length = length;
+        this.sampleRate = sampleRate;
+        this.buffer = audiocore.context.createBuffer(channels, length, sampleRate);
+        this.sound = new _Sound(audiocore, this.buffer);
+      }
+      /**
+      * Play the sound
+      */
+      play(volume, pitch, pan, loopit) {
+        return this.sound.play(volume, pitch, pan, loopit);
+      }
+      /**
+      * Write sample value to buffer
+      */
+      write(channel, position, value) {
+        if (channel === 0) {
+          const ch1 = this.buffer.getChannelData(0);
+          ch1[position] = value;
+        } else if (this.channels === 2) {
+          const ch2 = this.buffer.getChannelData(1);
+          ch2[position] = value;
+        }
+      }
+      /**
+      * Read sample value from buffer
+      */
+      read(channel, position) {
+        if (channel === 0) {
+          const ch1 = this.buffer.getChannelData(0);
+          return ch1[position];
+        } else if (this.channels === 2) {
+          const ch2 = this.buffer.getChannelData(1);
+          return ch2[position];
+        }
+        return 0;
+      }
+    };
+  }
+};
+export {
+  AudioCore,
+  Beeper,
+  Music,
+  Sound
+};
+//# sourceMappingURL=index.mjs.map