@ohos-ports/dm-howler 2.2.4-beta.1

package/dist/node-polyfill.js

@@ -0,0 +1,728 @@
+/**
+ * dm-howler Node.js runtime adapter (HarmonyOS / openharmony compatible).
+ *
+ * Installs a minimal, dependency-free browser-environment shim so that
+ * howler.js can load and operate inside a Node.js runtime:
+ *   - AudioContext  : pure-JS Web Audio graph (gain/panner/buffer nodes) with a
+ *                     real RIFF/WAVE decoder for AudioContext.decodeAudioData().
+ *   - XMLHttpRequest: adapter over Node http/https (remote URLs) and fs (local
+ *                     paths), returning ArrayBuffer responses for audio loading.
+ *   - Audio         : HTMLAudioElement stand-in exposing canPlayType() based on
+ *                     the codecs the adapter can actually decode, so
+ *                     Howler.codecs() reflects real capability.
+ *   - document/window/navigator: minimal stubs used by howler's unlock logic.
+ *
+ * This module is side-effect only and safe in browsers (it becomes a no-op when
+ * real browser globals are present).
+ */
+(function (global) {
+  'use strict';
+
+  var isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+  if (!isNode) {
+    return; // Real browser environment: nothing to do.
+  }
+
+  // Already running in a browser-like embedding with Web Audio support.
+  if (typeof global.AudioContext === 'function' &&
+      typeof global.Audio === 'function' &&
+      typeof global.document !== 'undefined') {
+    return;
+  }
+
+  var fs = null, path = null, http = null, https = null;
+  try { fs = require('fs'); } catch (e) {}
+  try { path = require('path'); } catch (e) {}
+  try { http = require('http'); } catch (e) {}
+  try { https = require('https'); } catch (e) {}
+
+  function defineGlobal(name, value) {
+    try {
+      Object.defineProperty(global, name, {
+        value: value, writable: true, configurable: true, enumerable: false
+      });
+    } catch (e) {
+      try { global[name] = value; } catch (e2) { /* ignore */ }
+    }
+  }
+
+  /* ------------------------------------------------------------------ *
+   * Codecs the adapter can decode (used by Audio.canPlayType).
+   * Currently RIFF/WAVE PCM (8/16/24/32-bit int and 32-bit float).
+   * ------------------------------------------------------------------ */
+  var MIME_SUPPORT = {
+    'audio/wav': 'probably',
+    'audio/wave': 'probably',
+    'audio/x-wav': 'probably',
+    'audio/vnd.wave': 'probably'
+  };
+  function mimeSupport(mime) {
+    if (typeof mime !== 'string') { return ''; }
+    var base = String(mime).toLowerCase().replace(/\s*;\s*$/, '');
+    if (MIME_SUPPORT[base]) { return MIME_SUPPORT[base]; }
+    // Strip codec parameters and retry (e.g. 'audio/wav; codecs="1"').
+    var head = base.split(';')[0];
+    if (MIME_SUPPORT[head]) { return MIME_SUPPORT[head]; }
+    return '';
+  }
+
+  /* ------------------------------------------------------------------ *
+   * RIFF/WAVE decoder -> { channels, sampleRate, length, samples[] }
+   * ------------------------------------------------------------------ */
+  function decodeWav(buffer) {
+    var view = new DataView(buffer);
+    if (buffer.byteLength < 44) { return null; }
+    if (view.getUint8(0) !== 0x52 || view.getUint8(1) !== 0x49 ||
+        view.getUint8(2) !== 0x46 || view.getUint8(3) !== 0x46) { return null; } // 'RIFF'
+    if (view.getUint8(8) !== 0x57 || view.getUint8(9) !== 0x41 ||
+        view.getUint8(10) !== 0x56 || view.getUint8(11) !== 0x45) { return null; } // 'WAVE'
+
+    var offset = 12, fmt = null, data = null;
+    while (offset + 8 <= buffer.byteLength) {
+      var id = String.fromCharCode(
+        view.getUint8(offset), view.getUint8(offset + 1),
+        view.getUint8(offset + 2), view.getUint8(offset + 3));
+      var size = view.getUint32(offset + 4, true);
+      var body = offset + 8;
+      if (id === 'fmt ' && size >= 16) {
+        fmt = {
+          format: view.getUint16(body, true),
+          channels: view.getUint16(body + 2, true),
+          sampleRate: view.getUint32(body + 4, true),
+          bitsPerSample: view.getUint16(body + 14, true)
+        };
+      } else if (id === 'data') {
+        var avail = buffer.byteLength - body;
+        data = new Uint8Array(buffer, body, Math.min(size, avail));
+      }
+      offset = body + size + (size % 2);
+      if (size === 0 || offset <= body) { break; }
+    }
+    if (!fmt || !data) { return null; }
+
+    var channels = fmt.channels || 1;
+    var bits = fmt.bitsPerSample || 16;
+    var bytesPer = bits / 8;
+    var frames = Math.floor(data.length / (bytesPer * channels));
+    if (frames < 0) { return null; }
+    // A header-only WAVE (data chunk of 0 bytes) yields one silent frame so
+    // that downstream consumers see a valid, non-zero-length AudioBuffer.
+    var silent = (frames === 0);
+    if (silent) { frames = 1; }
+    var isFloat = fmt.format === 3;
+    var samples = [];
+    for (var c = 0; c < channels; c++) {
+      var arr = new Float32Array(frames);
+      samples.push(arr);
+    }
+    for (var i = 0; i < frames && !silent; i++) {
+      for (var ch = 0; ch < channels; ch++) {
+        var p = (i * channels + ch) * bytesPer;
+        var v = 0;
+        if (isFloat && bits === 32) {
+          v = view.getFloat32(data.byteOffset + p, true);
+        } else if (bits === 8) {
+          v = (data[p] - 128) / 128;
+        } else if (bits === 16) {
+          v = view.getInt16(data.byteOffset + p, true) / 32768;
+        } else if (bits === 24) {
+          var b0 = data[p], b1 = data[p + 1], b2 = data[p + 2];
+          var x = (b2 << 16) | (b1 << 8) | b0;
+          if (x & 0x800000) { x |= ~0xFFFFFF; }
+          v = x / 8388608;
+        } else if (bits === 32) {
+          v = view.getInt32(data.byteOffset + p, true) / 2147483648;
+        }
+        samples[ch][i] = v;
+      }
+    }
+    return { channels: channels, sampleRate: fmt.sampleRate, length: frames, samples: samples };
+  }
+
+  /* ------------------------------------------------------------------ *
+   * Web Audio: AudioParam
+   * ------------------------------------------------------------------ */
+  function AudioParam(value) {
+    this.value = value;
+    this.defaultValue = value;
+    this.minValue = -3.4028234663852886e38;
+    this.maxValue = 3.4028234663852886e38;
+  }
+  AudioParam.prototype.setValueAtTime = function (v) { this.value = v; return this; };
+  AudioParam.prototype.linearRampToValueAtTime = function (v) { this.value = v; return this; };
+  AudioParam.prototype.exponentialRampToValueAtTime = function (v) { this.value = v; return this; };
+  AudioParam.prototype.setTargetAtTime = function (v) { this.value = v; return this; };
+  AudioParam.prototype.setValueCurveAtTime = function () { return this; };
+  AudioParam.prototype.cancelScheduledValues = function () { return this; };
+  AudioParam.prototype.cancelAndHoldAtTime = function () { return this; };
+
+  /* ------------------------------------------------------------------ *
+   * Web Audio: base node + concrete node types
+   * ------------------------------------------------------------------ */
+  function AudioNode(ctx) {
+    this.context = ctx;
+    this._connected = [];
+    this.numberOfInputs = 1;
+    this.numberOfOutputs = 1;
+    this.channelCount = 2;
+  }
+  AudioNode.prototype.connect = function (dest) {
+    if (dest && this._connected.indexOf(dest) === -1) { this._connected.push(dest); }
+    return dest;
+  };
+  AudioNode.prototype.disconnect = function () { this._connected.length = 0; };
+
+  function GainNode(ctx) {
+    AudioNode.call(this, ctx);
+    this.gain = new AudioParam(1);
+  }
+  GainNode.prototype = Object.create(AudioNode.prototype);
+
+  function PannerNode(ctx) {
+    AudioNode.call(this, ctx);
+    this.panningModel = 'HRTF';
+    this.distanceModel = 'inverse';
+    this.refDistance = 1;
+    this.maxDistance = 10000;
+    this.rolloffFactor = 1;
+    this.coneInnerAngle = 360;
+    this.coneOuterAngle = 360;
+    this.coneOuterGain = 0;
+    this.positionX = new AudioParam(0);
+    this.positionY = new AudioParam(0);
+    this.positionZ = new AudioParam(0);
+  }
+  PannerNode.prototype = Object.create(AudioNode.prototype);
+  PannerNode.prototype.setPosition = function (x, y, z) {
+    this.positionX.value = x; this.positionY.value = y; this.positionZ.value = z;
+  };
+  PannerNode.prototype.setOrientation = function () {};
+  PannerNode.prototype.orient = function (x, y, z, x2, y2, z2) {
+    if (typeof x === 'number') {
+      this.setPosition(x, y, z);
+      if (typeof x2 === 'number') { this.setOrientation(x2, y2, z2); }
+    }
+  };
+
+  function StereoPannerNode(ctx) {
+    AudioNode.call(this, ctx);
+    this.pan = new AudioParam(0);
+  }
+  StereoPannerNode.prototype = Object.create(AudioNode.prototype);
+
+  function AudioBufferSourceNode(ctx) {
+    AudioNode.call(this, ctx);
+    this.buffer = null;
+    this.loop = false;
+    this.loopStart = 0;
+    this.loopEnd = 0;
+    this.playbackRate = new AudioParam(1);
+    this.onended = null;
+  }
+  AudioBufferSourceNode.prototype = Object.create(AudioNode.prototype);
+  AudioBufferSourceNode.prototype.start = function (when, offset, duration) {
+    var self = this;
+    // Real audio output is not rendered in the Node adapter; the playback
+    // timeline is simulated so that duration/onended semantics stay correct.
+    this._startedAt = (typeof when === 'number' ? when : 0);
+    this._offset = (typeof offset === 'number' ? offset : 0);
+    var dur = 0;
+    if (this.buffer) {
+      dur = (typeof duration === 'number' ? duration : this.buffer.duration - this._offset);
+      if (this.loop) { dur = Infinity; }
+    }
+    if (typeof this.onplay === 'function') { this.onplay(); }
+    if (typeof this.onended === 'function' && isFinite(dur)) {
+      this._endedTimer = setTimeout(function () {
+        if (typeof self.onended === 'function') { self.onended(); }
+      }, Math.max(0, dur * 1000));
+    }
+  };
+  AudioBufferSourceNode.prototype.stop = function () {
+    if (this._endedTimer) { clearTimeout(this._endedTimer); this._endedTimer = null; }
+    if (typeof this.onended === 'function') { this.onended(); }
+  };
+  AudioBufferSourceNode.prototype.noteOn = function (when) { this.start(when); };
+  AudioBufferSourceNode.prototype.noteOff = function () { this.stop(); };
+
+  function AudioBuffer(ctx, channels, length, sampleRate) {
+    this.context = ctx;
+    this.numberOfChannels = channels;
+    this.length = length;
+    this.sampleRate = sampleRate;
+    this.duration = length / sampleRate;
+    this._samples = [];
+    for (var c = 0; c < channels; c++) { this._samples.push(new Float32Array(length)); }
+  }
+  AudioBuffer.prototype.getChannelData = function (channel) {
+    return this._samples[channel] || new Float32Array(this.length);
+  };
+  AudioBuffer.prototype.copyFromChannel = function (dest, ch) {
+    var src = this.getChannelData(ch);
+    dest.set(src.subarray(0, Math.min(dest.length, src.length)));
+  };
+  AudioBuffer.prototype.copyToChannel = function (src, ch) {
+    var dst = this.getChannelData(ch);
+    dst.set(src.subarray(0, Math.min(dst.length, src.length)));
+  };
+
+  function AudioListener(ctx) {
+    this.positionX = new AudioParam(0);
+    this.positionY = new AudioParam(0);
+    this.positionZ = new AudioParam(0);
+    this.forwardX = new AudioParam(0);
+    this.forwardY = new AudioParam(0);
+    this.forwardZ = new AudioParam(-1);
+    this.upX = new AudioParam(0);
+    this.upY = new AudioParam(1);
+    this.upZ = new AudioParam(0);
+  }
+  AudioListener.prototype.setPosition = function () {};
+  AudioListener.prototype.setOrientation = function () {};
+
+  function AudioDestinationNode(ctx) {
+    AudioNode.call(this, ctx);
+    this.maxChannelCount = 2;
+  }
+
+  /* ------------------------------------------------------------------ *
+   * AudioContext (pure JS)
+   * ------------------------------------------------------------------ */
+  function AudioContext() {
+    this.sampleRate = 44100;
+    this.state = 'running';
+    this.destination = new AudioDestinationNode(this);
+    this.listener = new AudioListener(this);
+    this._epoch = Date.now();
+    // Live playback clock: currentTime advances in real time.
+    var self = this;
+    Object.defineProperty(this, 'currentTime', {
+      get: function () { return (Date.now() - self._epoch) / 1000; },
+      configurable: true
+    });
+  }
+  AudioContext.prototype._tick = function () {
+    return (Date.now() - this._epoch) / 1000;
+  };
+  AudioContext.prototype.createGain = function () { return new GainNode(this); };
+  AudioContext.prototype.createGainNode = function () { return this.createGain(); };
+  AudioContext.prototype.createPanner = function () { return new PannerNode(this); };
+  AudioContext.prototype.createStereoPanner = function () { return new StereoPannerNode(this); };
+  AudioContext.prototype.createBufferSource = function () { return new AudioBufferSourceNode(this); };
+  AudioContext.prototype.createBuffer = function (channels, length, sampleRate) {
+    return new AudioBuffer(this, channels, length, sampleRate);
+  };
+  AudioContext.prototype.createScriptProcessor = function (bufferSize) {
+    var node = new AudioNode(this);
+    node.bufferSize = bufferSize || 4096;
+    node.onaudioprocess = null;
+    return node;
+  };
+  AudioContext.prototype.createDynamicsCompressor = function () {
+    var node = new GainNode(this);
+    node.threshold = new AudioParam(-24);
+    node.knee = new AudioParam(30);
+    node.ratio = new AudioParam(12);
+    node.attack = new AudioParam(0.003);
+    node.release = new AudioParam(0.25);
+    return node;
+  };
+  AudioContext.prototype.createBiquadFilter = function () {
+    var node = new GainNode(this);
+    node.type = 'lowpass';
+    node.frequency = new AudioParam(350);
+    node.Q = new AudioParam(1);
+    node.detune = new AudioParam(0);
+    node.gain = new AudioParam(0);
+    return node;
+  };
+  AudioContext.prototype.createOscillator = function () {
+    var node = new AudioNode(this);
+    node.type = 'sine';
+    node.frequency = new AudioParam(440);
+    node.detune = new AudioParam(0);
+    node.start = function () {};
+    node.stop = function () {};
+    return node;
+  };
+
+  /**
+   * Decode audio data. Accepts Node Buffer / ArrayBuffer / TypedArray.
+   * Supports RIFF/WAVE PCM; rejects anything the decoder cannot parse.
+   */
+  AudioContext.prototype.decodeAudioData = function (audioData, successCallback, errorCallback) {
+    var ctx = this;
+    var promise = new Promise(function (resolve, reject) {
+      var bytes = audioData;
+      try {
+        if (bytes && typeof Buffer !== 'undefined' && Buffer.isBuffer(bytes)) {
+          bytes = new Uint8Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+        } else if (bytes && bytes.buffer instanceof ArrayBuffer && !(bytes instanceof Uint8Array)) {
+          bytes = new Uint8Array(bytes.buffer.slice(0));
+        } else if (!(bytes instanceof Uint8Array)) {
+          bytes = new Uint8Array(bytes);
+        }
+        // Copy into a standalone ArrayBuffer (DataView alignment safety).
+        var ab = new ArrayBuffer(bytes.length);
+        new Uint8Array(ab).set(bytes);
+        var decoded = decodeWav(ab);
+        if (!decoded) { throw new Error('Unsupported audio format (RIFF/WAVE PCM supported)'); }
+        var buffer = new AudioBuffer(
+          ctx, decoded.channels, decoded.length, decoded.sampleRate);
+        for (var c = 0; c < decoded.channels; c++) {
+          buffer.getChannelData(c).set(decoded.samples[c]);
+        }
+        resolve(buffer);
+      } catch (err) {
+        reject(err);
+      }
+    });
+    if (typeof successCallback === 'function') {
+      promise.then(successCallback, errorCallback || function () {});
+    }
+    return promise;
+  };
+  AudioContext.prototype.suspend = function () { this.state = 'suspended'; return Promise.resolve(); };
+  AudioContext.prototype.resume = function () { this.state = 'running'; return Promise.resolve(); };
+  AudioContext.prototype.close = function () { this.state = 'closed'; return Promise.resolve(); };
+
+  /* ------------------------------------------------------------------ *
+   * XMLHttpRequest over Node http/https/fs
+   * ------------------------------------------------------------------ */
+  function XMLHttpRequest() {
+    this.readyState = 0;
+    this.status = 0;
+    this.statusText = '';
+    this.response = null;
+    this.responseText = '';
+    this.responseType = '';
+    this.withCredentials = false;
+    this.onreadystatechange = null;
+    this.onload = null;
+    this.onerror = null;
+    this.onabort = null;
+    this.onprogress = null;
+    this._listeners = {};
+    this._headers = {};
+    this._method = 'GET';
+    this._url = '';
+  }
+  XMLHttpRequest.UNSENT = 0;
+  XMLHttpRequest.OPENED = 1;
+  XMLHttpRequest.HEADERS_RECEIVED = 2;
+  XMLHttpRequest.LOADING = 3;
+  XMLHttpRequest.DONE = 4;
+  XMLHttpRequest.prototype._fire = function (type, event) {
+    var handler = this['on' + type];
+    if (typeof handler === 'function') { handler.call(this, event); }
+    var list = this._listeners[type];
+    if (list) {
+      for (var i = 0; i < list.length; i++) { list[i].call(this, event); }
+    }
+  };
+  XMLHttpRequest.prototype._setReadyState = function (state) {
+    this.readyState = state;
+    this._fire('readystatechange', null);
+  };
+  XMLHttpRequest.prototype.open = function (method, url) {
+    this._method = String(method || 'GET').toUpperCase();
+    this._url = String(url || '');
+    this.status = 0;
+    this.response = null;
+    this.responseText = '';
+    this._setReadyState(1);
+  };
+  XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
+    this._headers[String(name)] = String(value);
+  };
+  XMLHttpRequest.prototype.getResponseHeader = function () { return null; };
+  XMLHttpRequest.prototype.getAllResponseHeaders = function () { return ''; };
+  XMLHttpRequest.prototype.abort = function () {
+    if (this._req && typeof this._req.abort === 'function') { this._req.abort(); }
+    this._setReadyState(4);
+    this._fire('abort', null);
+  };
+  XMLHttpRequest.prototype.addEventListener = function (type, fn) {
+    (this._listeners[type] = this._listeners[type] || []).push(fn);
+  };
+  XMLHttpRequest.prototype.removeEventListener = function (type, fn) {
+    var list = this._listeners[type] || [];
+    var idx = list.indexOf(fn);
+    if (idx !== -1) { list.splice(idx, 1); }
+  };
+  XMLHttpRequest.prototype._finish = function (data) {
+    this._setReadyState(2);
+    this._setReadyState(3);
+    if (this.responseType === 'arraybuffer' || this.responseType === 'blob') {
+      this.response = data;
+    } else {
+      this.responseText = Buffer.from(data).toString('utf8');
+      this.response = this.responseText;
+    }
+    this._setReadyState(4);
+    this._fire('load', null);
+  };
+  XMLHttpRequest.prototype._fail = function (err) {
+    this._setReadyState(4);
+    this._fire('error', err);
+  };
+  XMLHttpRequest.prototype.send = function () {
+    var self = this;
+    var url = this._url;
+
+    // Local file paths (absolute, relative or file://) -> fs adapter.
+    if (!/^https?:\/\//i.test(url)) {
+      if (!fs) { setImmediate(function () { self._fail(new Error('fs unavailable')); }); return; }
+      var file = url;
+      if (/^file:\/\//i.test(file)) {
+        try { file = require('url').fileURLToPath(file); } catch (e) {}
+      }
+      try {
+        file = path ? path.resolve(process.cwd(), file) : file;
+      } catch (e) {}
+      fs.readFile(file, function (err, buf) {
+        if (err) { self._fail(err); return; }
+        self.status = 200;
+        self.statusText = 'OK';
+        self._finish(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+      });
+      return;
+    }
+
+    if (!http || !https) { setImmediate(function () { self._fail(new Error('http unavailable')); }); return; }
+    var mod = /^https:\/\//i.test(url) ? https : http;
+    try {
+      var parsed = new (require('url').URL)(url);
+      var req = mod.request({
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: this._method,
+        headers: this._headers
+      }, function (res) {
+        self.status = res.statusCode;
+        self.statusText = res.statusMessage || '';
+        var chunks = [];
+        res.on('data', function (c) { chunks.push(c); });
+        res.on('end', function () {
+          var buf = Buffer.concat(chunks);
+          self._finish(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+        });
+      });
+      req.on('error', function (err) { self._fail(err); });
+      req.end();
+      this._req = req;
+    } catch (err) {
+      setImmediate(function () { self._fail(err); });
+    }
+  };
+
+  /* ------------------------------------------------------------------ *
+   * HTMLAudioElement stand-in
+   * ------------------------------------------------------------------ */
+  function MediaError() { this.code = 4; this.message = ''; }
+  function Audio(src) {
+    this._src = src || '';
+    this._listeners = {};
+    this._duration = 0;
+    this.currentTime = 0;
+    this.volume = 1;
+    this.muted = false;
+    this.paused = true;
+    this.loop = false;
+    this.playbackRate = 1;
+    this.readyState = 0; // HAVE_NOTHING until load completes
+    this.networkState = 0;
+    this.error = null;
+    this._unlocked = false;
+    this.preload = 'auto';
+    this.controls = false;
+    this.autoplay = false;
+    if (src) { this._scheduleLoad(); }
+  }
+  Audio.HAVE_NOTHING = 0;
+  Audio.HAVE_METADATA = 1;
+  Audio.HAVE_CURRENT_DATA = 2;
+  Audio.HAVE_FUTURE_DATA = 3;
+  Audio.HAVE_ENOUGH_DATA = 4;
+  Audio.prototype.canPlayType = function (mime) { return mimeSupport(mime); };
+  Audio.prototype._fire = function (type) {
+    var self = this;
+    var handler = this['on' + type];
+    if (typeof handler === 'function') { handler.call(this, { type: type, target: this }); }
+    var list = this._listeners[type];
+    if (list) {
+      for (var i = 0; i < list.length; i++) { list[i].call(this, { type: type, target: self }); }
+    }
+  };
+  Audio.prototype.addEventListener = function (type, fn) {
+    (this._listeners[type] = this._listeners[type] || []).push(fn);
+  };
+  Audio.prototype.removeEventListener = function (type, fn) {
+    var list = this._listeners[type] || [];
+    var idx = list.indexOf(fn);
+    if (idx !== -1) { list.splice(idx, 1); }
+  };
+  Audio.prototype.dispatchEvent = function (evt) {
+    if (evt && evt.type) { this._fire(evt.type); }
+    return true;
+  };
+  Audio.prototype._scheduleLoad = function () {
+    var self = this;
+    // Read the real duration for local WAVE files when possible; other
+    // formats stay at duration 0 (the Web Audio backend handles decoding).
+    setImmediate(function () {
+      self.readyState = 1;
+      self._fire('loadstart');
+      var dur = 0;
+      try {
+        if (fs && self._src && !/^https?:\/\//i.test(self._src)) {
+          var file = path ? path.resolve(process.cwd(), self._src) : self._src;
+          var stat = fs.statSync(file);
+          var fd = fs.openSync(file, 'r');
+          var head = Buffer.alloc(4096);
+          var read = fs.readSync(fd, head, 0, 4096, 0);
+          fs.closeSync(fd);
+          var wav = decodeWav(head.buffer.slice(head.byteOffset, head.byteOffset + read));
+          if (wav && wav.sampleRate && wav.length) {
+            var bytesPerFrame = wav.channels * 2;
+            var dataBytes = Math.max(0, stat.size - 44);
+            dur = dataBytes / (bytesPerFrame * wav.sampleRate);
+          }
+        }
+      } catch (e) { /* probing failures keep duration 0 */ }
+      self._duration = dur;
+      self.readyState = 4;
+      self.networkState = 1;
+      self._fire('loadedmetadata');
+      self._fire('loadeddata');
+      self._fire('canplay');
+      self._fire('canplaythrough');
+    });
+  };
+  Object.defineProperty(Audio.prototype, 'duration', {
+    get: function () { return this._duration; }
+  });
+  Object.defineProperty(Audio.prototype, 'src', {
+    get: function () { return this._src; },
+    set: function (v) {
+      this._src = String(v || '');
+      this.readyState = 0;
+      if (this._src) { this._scheduleLoad(); }
+    }
+  });
+  Audio.prototype.load = function () {
+    this.readyState = 0;
+    if (this._src) { this._scheduleLoad(); }
+  };
+  Audio.prototype.play = function () {
+    this.paused = false;
+    var self = this;
+    setImmediate(function () {
+      self._fire('play');
+      self._fire('playing');
+    });
+    return Promise.resolve();
+  };
+  Audio.prototype.pause = function () {
+    this.paused = true;
+    this._fire('pause');
+  };
+  Audio.prototype.destroy = function () {};
+
+  /* ------------------------------------------------------------------ *
+   * Minimal document / navigator / window
+   * ------------------------------------------------------------------ */
+  var documentShim = {
+    readyState: 'complete',
+    hidden: false,
+    visibilityState: 'visible',
+    createElement: function (tag) {
+      var t = String(tag || '').toLowerCase();
+      if (t === 'audio') { return new Audio(); }
+      if (t === 'canvas') {
+        return {
+          getContext: function () { return null; },
+          width: 0, height: 0
+        };
+      }
+      return { style: {}, addEventListener: function () {}, removeEventListener: function () {} };
+    },
+    createElementNS: function (ns, tag) { return documentShim.createElement(tag); },
+    createTextNode: function (t) { return { nodeValue: t }; },
+    addEventListener: function () {},       // no user-gesture unlock needed on Node
+    removeEventListener: function () {},
+    getElementById: function () { return null; },
+    querySelector: function () { return null; },
+    querySelectorAll: function () { return []; },
+    documentElement: { style: {} },
+    body: { appendChild: function () {}, style: {} },
+    head: { appendChild: function () {}, style: {} }
+  };
+
+  defineGlobal('AudioContext', AudioContext);
+  defineGlobal('webkitAudioContext', AudioContext);
+  defineGlobal('OfflineAudioContext', AudioContext);
+  defineGlobal('Audio', Audio);
+  defineGlobal('XMLHttpRequest', XMLHttpRequest);
+  defineGlobal('document', documentShim);
+  defineGlobal('MediaError', MediaError);
+
+  // Minimal location: howler checks window.location.protocol when building URLs.
+  var locationShim = {
+    href: 'file://' + (function () { try { return process.cwd(); } catch (e) { return '/'; } })() + '/',
+    protocol: 'file:',
+    host: '',
+    hostname: '',
+    port: '',
+    origin: 'null',
+    pathname: '/',
+    search: '',
+    hash: ''
+  };
+  defineGlobal('location', locationShim);
+  if (global.window) { try { global.window.location = locationShim; } catch (e) {} }
+
+  // window points at the global object so `window.navigator` etc. resolve.
+  if (typeof global.window === 'undefined') {
+    defineGlobal('window', global);
+  }
+  // Make sure window also sees the shims when window !== global.
+  if (global.window && global.window !== global) {
+    ['AudioContext', 'webkitAudioContext', 'Audio', 'XMLHttpRequest', 'document']
+      .forEach(function (k) {
+        if (typeof global.window[k] === 'undefined') { global.window[k] = global[k]; }
+      });
+  }
+
+  // Node's built-in navigator lacks browser fields howler reads
+  // (appVersion/platform/userAgent). Ensure they exist.
+  var NAV_BASE = {
+    appVersion: '5.0 (Node.js; ' + (process.platform || 'ohos') + ') NodeAdapter',
+    platform: process.platform === 'openharmony' ? 'OpenHarmony' : (process.platform || 'node'),
+    userAgent: 'Node.js/' + (process.versions && process.versions.node ? process.versions.node : 'unknown'),
+    language: 'en-US',
+    languages: ['en-US'],
+    vendor: '',
+    maxTouchPoints: 0
+  };
+  if (typeof global.navigator === 'object' && global.navigator !== null) {
+    Object.keys(NAV_BASE).forEach(function (k) {
+      if (typeof global.navigator[k] === 'undefined') {
+        try { global.navigator[k] = NAV_BASE[k]; } catch (e) { /* read-only */ }
+      }
+    });
+  } else {
+    defineGlobal('navigator', Object.create(null, (function () {
+      var desc = {};
+      Object.keys(NAV_BASE).forEach(function (k) {
+        desc[k] = { value: NAV_BASE[k], writable: true, configurable: true, enumerable: true };
+      });
+      return desc;
+    })()));
+  }
+
+  // Mark that the adapter is active (used for diagnostics).
+  defineGlobal('__DM_HOWLER_NODE_ADAPTER__', true);
+
+})(typeof globalThis !== 'undefined' ? globalThis : (typeof self !== 'undefined' ? self : this));