@storyteller-platform/ghost-story 0.0.1

package/dist/vad/ActiveGateOg.cjs

@@ -0,0 +1,1366 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ActiveGateOg_exports = {};
+__export(ActiveGateOg_exports, {
+  createDynamicUint16Array: () => createDynamicUint16Array,
+  detectVoiceActivity: () => detectVoiceActivity
+});
+module.exports = __toCommonJS(ActiveGateOg_exports);
+var import_promises = require("fs/promises");
+var import_convert = require("../convert.cjs");
+var import_Ascii = require("../encodings/Ascii.cjs");
+var import_ObjectUtilities = require("../utilities/ObjectUtilities.cjs");
+async function detectVoiceActivity(filepath, options) {
+  var _a;
+  const { rawAudio } = await ensureRawAudio(filepath);
+  const channelCount = rawAudio.audioChannels.length;
+  const firstChannel = rawAudio.audioChannels[0];
+  if (!firstChannel) {
+    throw new Error("no audio channels found");
+  }
+  const sampleCount = firstChannel.length;
+  const sampleRate = rawAudio.sampleRate;
+  const audioDuration = getRawAudioDuration(rawAudio);
+  options = (0, import_ObjectUtilities.extendDeep)(defaultAdaptiveGateOptions, options);
+  const gateVAD = new AdaptiveGateVAD(sampleRate, channelCount, options);
+  const frameDuration = 0.01;
+  const frameRecords = [];
+  for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+    const timePosition = sampleIndex / sampleRate;
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      const channel = rawAudio.audioChannels[channelIndex];
+      if (!channel) {
+        throw new Error(`channel ${channelIndex} not found`);
+      }
+      const sample = channel[sampleIndex];
+      if (sample === void 0) {
+        throw new Error(`sample at index ${sampleIndex} not found`);
+      }
+      gateVAD.process(sample, channelIndex);
+    }
+    const lastRecord = frameRecords[frameRecords.length - 1];
+    if (frameRecords.length == 0 || lastRecord && timePosition > lastRecord.timePosition + frameDuration) {
+      const record = {
+        timePosition,
+        loudness: gateVAD.loudnessEstimator.currentLoudness,
+        minimumLoudness: gateVAD.minimumLoudnessEstimator.currentPeak,
+        maximumLoudness: gateVAD.maximumLoudnessEstimator.currentPeak
+      };
+      frameRecords.push(record);
+    }
+  }
+  const frameActive = [];
+  for (let i = 0; i < frameRecords.length; i++) {
+    frameActive[i] = false;
+  }
+  {
+    const backwardExtensionFrameCount = Math.floor(
+      options.backwardExtensionDuration / frameDuration
+    );
+    const relativeThreshold = options.relativeThreshold;
+    let extendedActivityStartIndex = frameRecords.length;
+    for (let i = frameRecords.length - 1; i >= 0; i--) {
+      const record = frameRecords[i];
+      if (!record) {
+        continue;
+      }
+      const referenceLoudness = Math.max(record.maximumLoudness, -30);
+      let isActive = false;
+      if (i >= extendedActivityStartIndex) {
+        isActive = true;
+      }
+      if (record.loudness >= referenceLoudness + relativeThreshold) {
+        isActive = true;
+        extendedActivityStartIndex = Math.max(
+          i - backwardExtensionFrameCount,
+          0
+        );
+      }
+      frameActive[i] = isActive;
+    }
+  }
+  const timeline = [];
+  for (let i = 0; i < frameRecords.length; i++) {
+    const record = frameRecords[i];
+    if (!record) {
+      console.warn("[ghost-story] No record found for frame", i);
+      continue;
+    }
+    const isActive = frameActive[i];
+    const activityText = isActive ? "active" : "inactive";
+    const startTime = record.timePosition;
+    const endTime = Math.min(startTime + frameDuration, audioDuration);
+    if (timeline.length == 0 || ((_a = timeline.at(-1)) == null ? void 0 : _a.text) != activityText) {
+      timeline.push({
+        type: "segment",
+        text: activityText,
+        startTime,
+        endTime
+      });
+    } else {
+      timeline.at(-1).endTime = endTime;
+    }
+  }
+  return timeline;
+}
+function getRawAudioDuration(rawAudio) {
+  if (rawAudio.audioChannels.length == 0 || rawAudio.sampleRate == 0 || !rawAudio.audioChannels[0]) {
+    return 0;
+  }
+  return rawAudio.audioChannels[0].length / rawAudio.sampleRate;
+}
+async function ensureRawAudio(input) {
+  const inputAsRawAudio = await decodeToChannels(input);
+  return inputAsRawAudio;
+}
+async function decodeToChannels(input) {
+  const outputPath = await (0, import_convert.fileToWav)(input);
+  const waveAudio = await readFileAsBinary(outputPath);
+  return decodeWaveToRawAudio(waveAudio);
+}
+function decodeWaveToRawAudio(waveFileBuffer, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
+  const rawAudio = decodeWaveToFloat32Channels(
+    waveFileBuffer,
+    ignoreTruncatedChunks,
+    ignoreOverflowingDataChunks
+  );
+  return { rawAudio };
+}
+class AdaptiveGateVAD {
+  constructor(sampleRate, channelCount, options) {
+    this.sampleRate = sampleRate;
+    this.channelCount = channelCount;
+    this.options = options;
+    this.channelHighpassFilters = [];
+    this.channelLowpassFilters = [];
+    for (let i = 0; i < this.channelCount; i++) {
+      this.channelHighpassFilters.push(
+        createHighpassFilter(this.sampleRate, options.lowCutoff)
+      );
+      this.channelLowpassFilters.push(
+        createLowpassFilter(this.sampleRate, options.highCutoff)
+      );
+    }
+    this.loudnessEstimator = new LoudnessEstimator({
+      sampleRate: this.sampleRate,
+      channelCount: this.channelCount,
+      positiveAdaptationRate: options.positiveAdaptationRate,
+      negativeAdaptationRate: options.negativeAdaptationRate,
+      initialEstimate: -60,
+      minimumLoudness: -60,
+      applyKWeighting: false
+    });
+    const ticksPerSecond = this.sampleRate * this.channelCount;
+    this.minimumLoudnessEstimator = new DecayingPeakEstimator(
+      {
+        kind: "minimum",
+        decayPerSecond: options.peakLoudnessDecay,
+        initialPeak: -60
+      },
+      ticksPerSecond
+    );
+    this.maximumLoudnessEstimator = new DecayingPeakEstimator(
+      {
+        kind: "maximum",
+        decayPerSecond: options.peakLoudnessDecay,
+        initialPeak: -60
+      },
+      ticksPerSecond
+    );
+  }
+  channelHighpassFilters;
+  channelLowpassFilters;
+  loudnessEstimator;
+  minimumLoudnessEstimator;
+  maximumLoudnessEstimator;
+  process(sample, channelIndex) {
+    const highpassFilter = this.channelHighpassFilters[channelIndex];
+    const lowpassFilter = this.channelLowpassFilters[channelIndex];
+    if (!highpassFilter || !lowpassFilter) {
+      throw new Error(`filters for channel ${channelIndex} not found`);
+    }
+    sample = highpassFilter.filter(sample);
+    sample = lowpassFilter.filter(sample);
+    this.loudnessEstimator.process(sample, channelIndex);
+    const currentLoudness = this.loudnessEstimator.currentLoudness;
+    this.minimumLoudnessEstimator.process(currentLoudness);
+    if (currentLoudness >= -60) {
+      this.maximumLoudnessEstimator.process(currentLoudness);
+    }
+  }
+}
+const defaultAdaptiveGateOptions = {
+  lowCutoff: 100,
+  highCutoff: 1e3,
+  positiveAdaptationRate: 400,
+  negativeAdaptationRate: 10,
+  peakLoudnessDecay: 4,
+  backwardExtensionDuration: 0.2,
+  relativeThreshold: -15
+};
+class LoudnessEstimator {
+  constructor(options) {
+    this.options = options;
+    const initialMeanSquares = decibelsToGainFactor(options.initialEstimate) ** 2;
+    const ticksPerSecond = this.options.sampleRate * this.options.channelCount;
+    for (let i = 0; i < options.channelCount; i++) {
+      const weightingFilter = new KWeightingFilter(options.sampleRate);
+      const channelMeanSquares = new SmoothEstimator(
+        options.positiveAdaptationRate / ticksPerSecond,
+        options.negativeAdaptationRate / ticksPerSecond,
+        initialMeanSquares
+      );
+      this.channelFilters.push(weightingFilter);
+      this.channelMeanSquares.push(channelMeanSquares);
+    }
+    this.minPower = decibelsToGainFactor(options.minimumLoudness) ** 2;
+  }
+  channelFilters = [];
+  channelMeanSquares = [];
+  minPower;
+  process(sample, channel) {
+    let filteredSample;
+    if (this.options.applyKWeighting) {
+      const filter = this.channelFilters[channel];
+      if (!filter) {
+        throw new Error(`channel filter ${channel} not found`);
+      }
+      filteredSample = filter.process(sample);
+    } else {
+      filteredSample = sample;
+    }
+    const filteredSampleSquared = filteredSample ** 2;
+    const channelMeanSquares = this.channelMeanSquares[channel];
+    if (!channelMeanSquares) {
+      throw new Error(`channel mean squares ${channel} not found`);
+    }
+    channelMeanSquares.update(filteredSampleSquared);
+    channelMeanSquares.estimate = Math.max(
+      channelMeanSquares.estimate,
+      this.minPower
+    );
+  }
+  get currentLoudness() {
+    let totalMeanSquares = 0;
+    for (let i = 0; i < this.options.channelCount; i++) {
+      const channelMeanSquare = this.channelMeanSquares[i];
+      if (!channelMeanSquare) {
+        throw new Error(`channel mean square ${i} not found`);
+      }
+      totalMeanSquares += channelMeanSquare.estimate;
+    }
+    const rms = Math.sqrt(totalMeanSquares / this.options.channelCount);
+    const rmsDecibels = gainFactorToDecibels(rms);
+    return rmsDecibels;
+  }
+  getCurrentRMSForChannel(channel) {
+    const channelMeanSquare = this.channelMeanSquares[channel];
+    if (!channelMeanSquare) {
+      throw new Error(`channel mean square ${channel} not found`);
+    }
+    return Math.sqrt(channelMeanSquare.estimate);
+  }
+}
+class DecayingPeakEstimator {
+  constructor(options, ticksPerSecond) {
+    this.options = options;
+    this.ticksPerSecond = ticksPerSecond;
+    this.currentPeak = options.initialPeak;
+    this.decayPerTick = this.options.decayPerSecond / this.ticksPerSecond;
+    this.process = options.kind === "maximum" ? this.processMaximum.bind(this) : this.processMinimum.bind(this);
+  }
+  decayPerTick;
+  currentPeak;
+  process;
+  processMaximum(value) {
+    this.currentPeak -= this.decayPerTick;
+    this.currentPeak = Math.max(value, this.currentPeak);
+  }
+  processMinimum(value) {
+    this.currentPeak += this.decayPerTick;
+    this.currentPeak = Math.min(value, this.currentPeak);
+  }
+}
+function createLowpassFilter(sampleRate, cutoffFrequency, q = 0.7071) {
+  return createFilter("lowpass", sampleRate, cutoffFrequency, q, 0);
+}
+function createHighpassFilter(sampleRate, cutoffFrequency, q = 0.7071) {
+  return createFilter("highpass", sampleRate, cutoffFrequency, q, 0);
+}
+function createHighshelfFilter(sampleRate, midpointFrequency, gain) {
+  return createFilter("highshelf", sampleRate, midpointFrequency, 0, gain);
+}
+function createFilter(filterType, sampleRate, frequency, q, gain) {
+  const coefficients = getFilterCoefficients(
+    filterType,
+    sampleRate,
+    frequency,
+    q,
+    gain
+  );
+  return new BiquadFilter(coefficients);
+}
+class BiquadFilter {
+  b0 = 0;
+  b1 = 0;
+  b2 = 0;
+  a1 = 0;
+  a2 = 0;
+  prevInput1 = 0;
+  prevInput2 = 0;
+  prevOutput1 = 0;
+  prevOutput2 = 0;
+  constructor(coefficients) {
+    this.setCoefficients(coefficients);
+  }
+  filter(sample) {
+    const filteredSample = this.b0 * sample + this.b1 * this.prevInput1 + this.b2 * this.prevInput2 - this.a1 * this.prevOutput1 - this.a2 * this.prevOutput2;
+    this.prevInput2 = this.prevInput1;
+    this.prevInput1 = sample;
+    this.prevOutput2 = this.prevOutput1;
+    this.prevOutput1 = filteredSample;
+    return filteredSample;
+  }
+  filterSamplesInPlace(samples) {
+    for (let i = 0; i < samples.length; i++) {
+      const sample = samples[i];
+      if (sample === void 0) {
+        throw new Error(`sample at index ${i} not found`);
+      }
+      samples[i] = this.filter(sample);
+    }
+  }
+  reset() {
+    this.prevInput1 = 0;
+    this.prevInput2 = 0;
+    this.prevOutput1 = 0;
+    this.prevOutput2 = 0;
+  }
+  setCoefficients(coefficients) {
+    this.b0 = coefficients.b0;
+    this.b1 = coefficients.b1;
+    this.b2 = coefficients.b2;
+    this.a1 = coefficients.a1;
+    this.a2 = coefficients.a2;
+  }
+}
+function getFilterCoefficients(filterType, sampleRate, centerFrequency, q, gain) {
+  const nyquistFrequency = sampleRate / 2;
+  const freqRatio = clamp(centerFrequency / nyquistFrequency, 0, 1);
+  return filterCoefficientsFunction[filterType](freqRatio, q, gain);
+}
+function getLowpassFilterCoefficients(freqRatio, q, _gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  if (freqRatio == 1) {
+    b0 = 1;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else {
+    const theta = Math.PI * freqRatio;
+    const alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+    const cosw = Math.cos(theta);
+    const beta = (1 - cosw) / 2;
+    b0 = beta;
+    b1 = 2 * beta;
+    b2 = beta;
+    a0 = 1 + alpha;
+    a1 = -2 * cosw;
+    a2 = 1 - alpha;
+  }
+  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+}
+function getHighpassFilterCoefficients(freqRatio, q, _gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  if (freqRatio == 1) {
+    b0 = 0;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else if (freqRatio == 0) {
+    b0 = 1;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else {
+    const theta = Math.PI * freqRatio;
+    const alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+    const cosw = Math.cos(theta);
+    const beta = (1 + cosw) / 2;
+    b0 = beta;
+    b1 = -2 * beta;
+    b2 = beta;
+    a0 = 1 + alpha;
+    a1 = -2 * cosw;
+    a2 = 1 - alpha;
+  }
+  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+}
+function getBandpassFilterCoefficients(freqRatio, q, _gain = 0) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  if (freqRatio > 0 && freqRatio < 1) {
+    const w0 = Math.PI * freqRatio;
+    if (q > 0) {
+      const alpha = Math.sin(w0) / (2 * q);
+      const k = Math.cos(w0);
+      b0 = alpha;
+      b1 = 0;
+      b2 = -alpha;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+      coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+    }
+  } else {
+    coefficients = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 };
+  }
+  return coefficients;
+}
+function getLowShelfFilterCoefficients(freqRatio, _q = 0, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  const S = 1;
+  const A = Math.pow(10, gain / 40);
+  if (freqRatio == 1) {
+    coefficients = { b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0 };
+  } else if (freqRatio == 0) {
+    coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+  } else {
+    const w0 = Math.PI * freqRatio;
+    const alpha = 1 / 2 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
+    const k = Math.cos(w0);
+    const k2 = 2 * Math.sqrt(A) * alpha;
+    const Ap1 = A + 1;
+    const Am1 = A - 1;
+    b0 = A * (Ap1 - Am1 * k + k2);
+    b1 = 2 * A * (Am1 - Ap1 * k);
+    b2 = A * (Ap1 - Am1 * k - k2);
+    a0 = Ap1 + Am1 * k + k2;
+    a1 = -2 * (Am1 + Ap1 * k);
+    a2 = Ap1 + Am1 * k - k2;
+    coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+  }
+  return coefficients;
+}
+function getHighShelfFilterCoefficients(freqRatio, _q = 0, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  const A = Math.pow(10, gain / 40);
+  if (freqRatio == 1) {
+    coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+  } else if (freqRatio > 0) {
+    const w0 = Math.PI * freqRatio;
+    const S = 1;
+    const alpha = 0.5 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
+    const k = Math.cos(w0);
+    const k2 = 2 * Math.sqrt(A) * alpha;
+    const Ap1 = A + 1;
+    const Am1 = A - 1;
+    b0 = A * (Ap1 + Am1 * k + k2);
+    b1 = -2 * A * (Am1 + Ap1 * k);
+    b2 = A * (Ap1 + Am1 * k - k2);
+    a0 = Ap1 - Am1 * k + k2;
+    a1 = 2 * (Am1 - Ap1 * k);
+    a2 = Ap1 - Am1 * k - k2;
+    coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    coefficients = { b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0 };
+  }
+  return coefficients;
+}
+function getPeakingFilterCoefficients(freqRatio, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  const A = Math.pow(10, gain / 40);
+  if (freqRatio > 0 && freqRatio < 1) {
+    if (q > 0) {
+      const w0 = Math.PI * freqRatio;
+      const alpha = Math.sin(w0) / (2 * q);
+      const k = Math.cos(w0);
+      b0 = 1 + alpha * A;
+      b1 = -2 * k;
+      b2 = 1 - alpha * A;
+      a0 = 1 + alpha / A;
+      a1 = -2 * k;
+      a2 = 1 - alpha / A;
+      coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      coefficients = { b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0 };
+    }
+  } else {
+    coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+  }
+  return coefficients;
+}
+function getNotchFilterCoefficients(freqRatio, q, _gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  if (freqRatio > 0 && freqRatio < 1) {
+    if (q > 0) {
+      const w0 = Math.PI * freqRatio;
+      const alpha = Math.sin(w0) / (2 * q);
+      const k = Math.cos(w0);
+      b0 = 1;
+      b1 = -2 * k;
+      b2 = 1;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+      coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      coefficients = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 };
+    }
+  } else {
+    coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+  }
+  return coefficients;
+}
+function getAllpassFilterCoefficients(freqRatio, q, _gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coefficients;
+  if (freqRatio > 0 && freqRatio < 1) {
+    if (q > 0) {
+      const w0 = Math.PI * freqRatio;
+      const alpha = Math.sin(w0) / (2 * q);
+      const k = Math.cos(w0);
+      b0 = 1 - alpha;
+      b1 = -2 * k;
+      b2 = 1 + alpha;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+      coefficients = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      coefficients = { b0: -1, b1: 0, b2: 0, a1: 0, a2: 0 };
+    }
+  } else {
+    coefficients = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+  }
+  return coefficients;
+}
+function normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2) {
+  const scale = 1 / a0;
+  return {
+    b0: b0 * scale,
+    b1: b1 * scale,
+    b2: b2 * scale,
+    a1: a1 * scale,
+    a2: a2 * scale
+  };
+}
+function clamp(num, min, max) {
+  return Math.max(min, Math.min(max, num));
+}
+const filterCoefficientsFunction = {
+  lowpass: getLowpassFilterCoefficients,
+  highpass: getHighpassFilterCoefficients,
+  bandpass: getBandpassFilterCoefficients,
+  lowshelf: getLowShelfFilterCoefficients,
+  highshelf: getHighShelfFilterCoefficients,
+  peaking: getPeakingFilterCoefficients,
+  notch: getNotchFilterCoefficients,
+  allpass: getAllpassFilterCoefficients
+};
+class SmoothEstimator {
+  constructor(positiveAdaptationRate, negativeAdaptationRate, initialEstimate = 0) {
+    this.positiveAdaptationRate = positiveAdaptationRate;
+    this.negativeAdaptationRate = negativeAdaptationRate;
+    this.estimate = initialEstimate;
+  }
+  estimate;
+  update(target, adaptaionRateFactor = 1) {
+    const residual = target - this.estimate;
+    const adaptationRate = residual >= 0 ? this.positiveAdaptationRate : this.negativeAdaptationRate;
+    const stepSize = residual * adaptationRate * adaptaionRateFactor;
+    this.estimate += stepSize;
+  }
+  updateDamped(target, dampingReference, dampingCurvature, adaptationRateFactor = 1) {
+    const residual = target - this.estimate;
+    const scaledResidualMagnitude = Math.abs(residual) * dampingCurvature;
+    const dampingFactor = scaledResidualMagnitude / (scaledResidualMagnitude + dampingReference);
+    const adaptationRate = residual >= 0 ? this.positiveAdaptationRate : this.negativeAdaptationRate;
+    const stepSize = residual * adaptationRate * adaptationRateFactor * dampingFactor;
+    this.estimate += stepSize;
+  }
+}
+class KWeightingFilter {
+  constructor(sampleRate, useStandard44100Filters = false) {
+    this.sampleRate = sampleRate;
+    this.useStandard44100Filters = useStandard44100Filters;
+    if (useStandard44100Filters) {
+      this.highShelfFilter = new BiquadFilter({
+        b0: 1.53512485958697,
+        b1: -2.69169618940638,
+        b2: 1.19839281085285,
+        a1: -1.69065929318241,
+        a2: 0.73248077421585
+      });
+      this.highPassFilter = new BiquadFilter({
+        b0: 1,
+        b1: -2,
+        b2: 1,
+        a1: -1.99004745483398,
+        a2: 0.99007225036621
+      });
+    } else {
+      this.highShelfFilter = createHighshelfFilter(sampleRate, 2e3, 4);
+      this.highPassFilter = createHighpassFilter(sampleRate, 1.5, 0.01);
+    }
+  }
+  highShelfFilter;
+  highPassFilter;
+  process(sample) {
+    let outputSample = sample;
+    outputSample = this.highShelfFilter.filter(outputSample);
+    outputSample = this.highPassFilter.filter(outputSample);
+    return outputSample;
+  }
+}
+function gainFactorToDecibels(gainFactor) {
+  return gainFactor <= 1e-5 ? -100 : 20 * Math.log10(gainFactor);
+}
+function decibelsToGainFactor(decibels) {
+  return decibels <= -100 ? 0 : Math.pow(10, 0.05 * decibels);
+}
+function decodeWaveToFloat32Channels(waveData, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
+  const {
+    decodedAudioBuffer,
+    sampleRate,
+    channelCount,
+    bitDepth,
+    sampleFormat
+  } = decodeWaveToBuffer(
+    waveData,
+    ignoreTruncatedChunks,
+    ignoreOverflowingDataChunks
+  );
+  const audioChannels = bufferToFloat32Channels(
+    decodedAudioBuffer,
+    channelCount,
+    bitDepth,
+    sampleFormat
+  );
+  return {
+    audioChannels,
+    sampleRate
+  };
+}
+function decodeWaveToBuffer(waveData, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
+  let readOffset = 0;
+  const riffId = (0, import_Ascii.decodeAscii)(waveData.subarray(readOffset, readOffset + 4));
+  if (riffId !== "RIFF") {
+    throw new Error("Not a valid wave file. No RIFF id found at offset 0.");
+  }
+  readOffset += 4;
+  let riffChunkSize = readUint32LE(waveData, readOffset);
+  readOffset += 4;
+  const waveId = (0, import_Ascii.decodeAscii)(waveData.subarray(readOffset, readOffset + 4));
+  if (waveId !== "WAVE") {
+    throw new Error("Not a valid wave file. No WAVE id found at offset 8.");
+  }
+  if (ignoreOverflowingDataChunks && riffChunkSize === 4294967295) {
+    riffChunkSize = waveData.length - 8;
+  }
+  if (riffChunkSize < waveData.length - 8) {
+    throw new Error(
+      `RIFF chunk length ${riffChunkSize} is smaller than the remaining size of the buffer (${waveData.length - 8})`
+    );
+  }
+  if (!ignoreTruncatedChunks && riffChunkSize > waveData.length - 8) {
+    throw new Error(
+      `RIFF chunk length (${riffChunkSize}) is greater than the remaining size of the buffer (${waveData.length - 8})`
+    );
+  }
+  readOffset += 4;
+  let formatSubChunkBodyBuffer;
+  const dataBuffers = [];
+  while (true) {
+    const subChunkIdentifier = (0, import_Ascii.decodeAscii)(
+      waveData.subarray(readOffset, readOffset + 4)
+    );
+    readOffset += 4;
+    let subChunkSize = readUint32LE(waveData, readOffset);
+    readOffset += 4;
+    if (!ignoreTruncatedChunks && subChunkSize > waveData.length - readOffset) {
+      throw new Error(
+        `Encountered a '${subChunkIdentifier}' subchunk with a size of ${subChunkSize} which is greater than the remaining size of the buffer (${waveData.length - readOffset})`
+      );
+    }
+    if (subChunkIdentifier === "fmt ") {
+      formatSubChunkBodyBuffer = waveData.subarray(
+        readOffset,
+        readOffset + subChunkSize
+      );
+    } else if (subChunkIdentifier === "data") {
+      if (!formatSubChunkBodyBuffer) {
+        throw new Error(
+          "A data subchunk was encountered before a format subchunk"
+        );
+      }
+      if (ignoreOverflowingDataChunks && subChunkSize === 4294967295) {
+        subChunkSize = waveData.length - readOffset;
+      }
+      const subChunkData = waveData.subarray(
+        readOffset,
+        readOffset + subChunkSize
+      );
+      dataBuffers.push(subChunkData);
+    }
+    readOffset += subChunkSize;
+    if (readOffset >= waveData.length) {
+      break;
+    }
+  }
+  if (!formatSubChunkBodyBuffer) {
+    throw new Error("No format subchunk was found in the wave file");
+  }
+  if (dataBuffers.length === 0) {
+    throw new Error("No data subchunks were found in the wave file");
+  }
+  const waveFormat = WaveFormatHeader.deserializeFrom(formatSubChunkBodyBuffer);
+  const sampleFormat = waveFormat.sampleFormat;
+  const channelCount = waveFormat.channelCount;
+  const sampleRate = waveFormat.sampleRate;
+  const bitDepth = waveFormat.bitDepth;
+  const speakerPositionMask = waveFormat.speakerPositionMask;
+  const decodedAudioBuffer = concatUint8Arrays(dataBuffers);
+  return {
+    decodedAudioBuffer,
+    sampleRate,
+    channelCount,
+    bitDepth,
+    sampleFormat,
+    speakerPositionMask
+  };
+}
+function concatUint8Arrays(arrays) {
+  return concatTypedArrays(Uint8Array, arrays);
+}
+function concatTypedArrays(TypedArrayConstructor, arrays) {
+  let totalLength = 0;
+  for (const array of arrays) {
+    totalLength += array.length;
+  }
+  const result = new TypedArrayConstructor(totalLength);
+  let writeOffset = 0;
+  for (const array of arrays) {
+    result.set(array, writeOffset);
+    writeOffset += array.length;
+  }
+  return result;
+}
+function readUint16LE(buffer, offset) {
+  const byte0 = buffer[offset];
+  const byte1 = buffer[offset + 1];
+  if (byte0 === void 0 || byte1 === void 0) {
+    throw new Error(`buffer access out of bounds at offset ${offset}`);
+  }
+  return byte0 | byte1 << 8;
+}
+function writeUint16LE(buffer, value, offset) {
+  if (value < 0 || value > 65535) {
+    throw new Error(
+      `Value ${value} is outside the range of a 16-bit unsigned integer`
+    );
+  }
+  buffer[offset] = value & 255;
+  buffer[offset + 1] = value >>> 8 & 255;
+}
+function readUint32LE(buffer, offset) {
+  return readInt32LE(buffer, offset) >>> 0;
+}
+function writeUint32LE(buffer, value, offset) {
+  if (value < 0 || value > 4294967295) {
+    throw new Error(
+      `Value ${value} is outside the range of a 32-bit unsigned integer`
+    );
+  }
+  buffer[offset] = value & 255;
+  buffer[offset + 1] = value >>> 8 & 255;
+  buffer[offset + 2] = value >>> 16 & 255;
+  buffer[offset + 3] = value >>> 24 & 255;
+}
+class WaveFormatHeader {
+  sampleFormat;
+  // 2 bytes LE
+  channelCount;
+  // 2 bytes LE
+  sampleRate;
+  // 4 bytes LE
+  get byteRate() {
+    return this.sampleRate * this.bytesPerSample * this.channelCount;
+  }
+  // 4 bytes LE
+  get blockAlign() {
+    return this.bytesPerSample * this.channelCount;
+  }
+  // 2 bytes LE
+  bitDepth;
+  // 2 bytes LE
+  speakerPositionMask;
+  // 4 bytes LE
+  get guid() {
+    return sampleFormatToGuid[this.sampleFormat];
+  }
+  // 16 bytes BE
+  get bytesPerSample() {
+    return this.bitDepth / 8;
+  }
+  constructor(channelCount, sampleRate, bitDepth, sampleFormat, speakerPositionMask = 0) {
+    this.sampleFormat = sampleFormat;
+    this.channelCount = channelCount;
+    this.sampleRate = sampleRate;
+    this.bitDepth = bitDepth;
+    this.speakerPositionMask = speakerPositionMask;
+  }
+  serialize(useExtensibleFormat) {
+    const sampleFormatId = this.sampleFormat;
+    const serializedSize = sampleFormatToSerializedSize[sampleFormatId];
+    const result = new Uint8Array(serializedSize);
+    writeAscii(result, "fmt ", 0);
+    writeUint32LE(result, serializedSize - 8, 4);
+    writeUint16LE(result, sampleFormatId, 8);
+    writeUint16LE(result, this.channelCount, 10);
+    writeUint32LE(result, this.sampleRate, 12);
+    writeUint32LE(result, this.byteRate, 16);
+    writeUint16LE(result, this.blockAlign, 20);
+    writeUint16LE(result, this.bitDepth, 22);
+    if (useExtensibleFormat) {
+      writeUint16LE(result, serializedSize - 26, 24);
+      writeUint16LE(result, this.bitDepth, 26);
+      writeUint32LE(result, this.speakerPositionMask, 28);
+      if (this.guid) {
+        result.set(decodeHex(this.guid), 32);
+      } else {
+        throw new Error(
+          `Extensible format is not supported for sample format ${this.sampleFormat}`
+        );
+      }
+    }
+    return result;
+  }
+  static deserializeFrom(formatChunkBody) {
+    let sampleFormat = readUint16LE(formatChunkBody, 0);
+    const channelCount = readUint16LE(formatChunkBody, 2);
+    const sampleRate = readUint32LE(formatChunkBody, 4);
+    const bitDepth = readUint16LE(formatChunkBody, 14);
+    let speakerPositionMask = 0;
+    if (sampleFormat === 65534) {
+      if (formatChunkBody.length < 40) {
+        throw new Error(
+          `Format subchunk specifies a format id of 65534 (extensible) but its body size is ${formatChunkBody.length} bytes, which is smaller than the minimum expected of 40 bytes`
+        );
+      }
+      speakerPositionMask = readUint16LE(formatChunkBody, 20);
+      const guid = encodeHex(formatChunkBody.subarray(24, 40));
+      if (guid === sampleFormatToGuid[SampleFormat.PCM]) {
+        sampleFormat = SampleFormat.PCM;
+      } else if (guid === sampleFormatToGuid[SampleFormat.Float]) {
+        sampleFormat = SampleFormat.Float;
+      } else if (guid === sampleFormatToGuid[SampleFormat.Alaw]) {
+        sampleFormat = SampleFormat.Alaw;
+      } else if (guid === sampleFormatToGuid[SampleFormat.Mulaw]) {
+        sampleFormat = SampleFormat.Mulaw;
+      } else {
+        throw new Error(
+          `Unsupported format GUID in extended format subchunk: ${guid}`
+        );
+      }
+    }
+    if (sampleFormat === SampleFormat.PCM) {
+      if (bitDepth !== 8 && bitDepth !== 16 && bitDepth !== 24 && bitDepth !== 32) {
+        throw new Error(
+          `PCM audio has a bit depth of ${bitDepth}, which is not supported`
+        );
+      }
+    } else if (sampleFormat === SampleFormat.Float) {
+      if (bitDepth !== 32 && bitDepth !== 64) {
+        throw new Error(
+          `IEEE float audio has a bit depth of ${bitDepth}, which is not supported`
+        );
+      }
+    } else if (sampleFormat === SampleFormat.Alaw) {
+      if (bitDepth !== 8) {
+        throw new Error(
+          `Alaw audio has a bit depth of ${bitDepth}, which is not supported`
+        );
+      }
+    } else if (sampleFormat === SampleFormat.Mulaw) {
+      if (bitDepth !== 8) {
+        throw new Error(
+          `Mulaw audio has a bit depth of ${bitDepth}, which is not supported`
+        );
+      }
+    } else {
+      throw new Error(`Wave audio format id ${sampleFormat} is not supported`);
+    }
+    return new WaveFormatHeader(
+      channelCount,
+      sampleRate,
+      bitDepth,
+      sampleFormat,
+      speakerPositionMask
+    );
+  }
+}
+const SampleFormat = {
+  PCM: 1,
+  Float: 3,
+  Alaw: 6,
+  Mulaw: 7
+};
+const sampleFormatToSerializedSize = {
+  [SampleFormat.PCM]: 24,
+  [SampleFormat.Float]: 26,
+  [SampleFormat.Alaw]: 26,
+  [SampleFormat.Mulaw]: 26,
+  65534: 48
+};
+const sampleFormatToGuid = {
+  [SampleFormat.PCM]: "0100000000001000800000aa00389b71",
+  [SampleFormat.Float]: "0300000000001000800000aa00389b71",
+  [SampleFormat.Alaw]: "0600000000001000800000aa00389b71",
+  [SampleFormat.Mulaw]: "0700000000001000800000aa00389b71"
+};
+function bufferToFloat32Channels(audioBuffer, channelCount, sourceBitDepth, sourceSampleFormat) {
+  let interleavedChannels;
+  if (sourceSampleFormat === SampleFormat.PCM && sourceBitDepth === 16) {
+    interleavedChannels = int16PcmToFloat32(bytesLEToInt16Array(audioBuffer));
+  } else {
+    throw new Error(`Unsupported PCM bit depth: ${sourceBitDepth}`);
+  }
+  audioBuffer = new Uint8Array(0);
+  return deinterleaveChannels(interleavedChannels, channelCount);
+}
+function readInt32LE(buffer, offset) {
+  const byte0 = buffer[offset];
+  const byte1 = buffer[offset + 1];
+  const byte2 = buffer[offset + 2];
+  const byte3 = buffer[offset + 3];
+  if (byte0 === void 0 || byte1 === void 0 || byte2 === void 0 || byte3 === void 0) {
+    throw new Error(`buffer access out of bounds at offset ${offset}`);
+  }
+  const value = byte0 | byte1 << 8 | byte2 << 16 | byte3 << 24;
+  return value;
+}
+function interleaveChannels(channels) {
+  const channelCount = channels.length;
+  const firstChannel = channels[0];
+  if (!firstChannel) {
+    throw new Error("Empty channel array received");
+  }
+  if (channelCount === 1) {
+    return firstChannel;
+  }
+  const sampleCount = firstChannel.length;
+  const result = new Float32Array(sampleCount * channelCount);
+  let writeIndex = 0;
+  for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      const channel = channels[channelIndex];
+      if (!channel) {
+        throw new Error(`channel ${channelIndex} not found`);
+      }
+      const sample = channel[sampleIndex];
+      if (sample === void 0) {
+        throw new Error(
+          `sample at index ${sampleIndex} not found in channel ${channelIndex}`
+        );
+      }
+      result[writeIndex++] = sample;
+    }
+  }
+  return result;
+}
+function deinterleaveChannels(interleavedChannels, channelCount) {
+  if (channelCount < 1) {
+    throw new Error(
+      `Invalid channel count of ${channelCount} received, which is smaller than 1`
+    );
+  }
+  if (channelCount === 1) {
+    return [interleavedChannels];
+  }
+  if (interleavedChannels.length % channelCount !== 0) {
+    throw new Error(
+      `Size of interleaved channels (${interleaveChannels.length}) is not a multiple of channel count (${channelCount})`
+    );
+  }
+  const sampleCount = interleavedChannels.length / channelCount;
+  const channels = [];
+  for (let i = 0; i < channelCount; i++) {
+    channels.push(new Float32Array(sampleCount));
+  }
+  let readIndex = 0;
+  for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      const channel = channels[channelIndex];
+      if (!channel) {
+        throw new Error(`channel ${channelIndex} not found`);
+      }
+      const sample = interleavedChannels[readIndex++];
+      if (sample === void 0) {
+        throw new Error(
+          `interleaved sample at index ${readIndex - 1} not found`
+        );
+      }
+      channel[sampleIndex] = sample;
+    }
+  }
+  return channels;
+}
+function int16PcmToFloat32(input) {
+  const sampleCount = input.length;
+  const output = new Float32Array(sampleCount);
+  for (let i = 0; i < sampleCount; i++) {
+    const sample = input[i];
+    if (sample === void 0) {
+      throw new Error(`input sample at index ${i} not found`);
+    }
+    output[i] = sample * (1 / 32768);
+  }
+  return output;
+}
+function writeAscii(buffer, asciiString, writeStartOffset) {
+  const writeEndOffset = Math.min(
+    writeStartOffset + asciiString.length,
+    buffer.length
+  );
+  let readOffset = 0;
+  let writeOffset = writeStartOffset;
+  while (writeOffset < writeEndOffset) {
+    const charCode = asciiString.charCodeAt(readOffset++);
+    if (charCode >= 128) {
+      throw new Error(
+        `Character '${asciiString[readOffset]}' (code: ${charCode}) at offset ${readOffset} can't be encoded as ASCII`
+      );
+    }
+    buffer[writeOffset++] = charCode;
+  }
+}
+const isLittleEndianArch = testIfLittleEndian();
+function testIfLittleEndian() {
+  const uint16Array = new Uint16Array([4386]);
+  const bytes = new Uint8Array(uint16Array.buffer);
+  return bytes[0] === 34;
+}
+function reverseByteGroups(bytes, groupSize) {
+  const result = bytes.slice();
+  reverseByteGroupsInPlace(result, groupSize);
+  return result;
+}
+function reverseByteGroupsInPlace(bytes, groupSize) {
+  if (bytes.length % groupSize !== 0) {
+    throw new Error(`Byte count must be an integer multiple of the group size.`);
+  }
+  const halfGroupSize = Math.floor(groupSize / 2);
+  for (let offset = 0; offset < bytes.length; offset += groupSize) {
+    const groupFirstElementOffset = offset;
+    const groupLastElementOffset = offset + groupSize - 1;
+    for (let i = 0; i < halfGroupSize; i++) {
+      const offset1 = groupFirstElementOffset + i;
+      const offset2 = groupLastElementOffset - i;
+      const valueAtOffset1 = bytes[offset1];
+      const valueAtOffset2 = bytes[offset2];
+      if (valueAtOffset1 === void 0 || valueAtOffset2 === void 0) {
+        throw new Error(
+          `bytes access out of bounds at offsets ${offset1}, ${offset2}`
+        );
+      }
+      bytes[offset1] = valueAtOffset2;
+      bytes[offset2] = valueAtOffset1;
+    }
+  }
+}
+function reverseByteGroupsIfBigEndian(bytes, groupSize) {
+  if (isLittleEndianArch) {
+    return bytes;
+  } else {
+    return reverseByteGroups(bytes, groupSize);
+  }
+}
+function bytesLEToInt16Array(bytes) {
+  bytes = reverseByteGroupsIfBigEndian(bytes, 2);
+  return new Int16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+}
+class DynamicTypedArray {
+  constructor(TypedArrayConstructor, initialCapacity = 4) {
+    this.TypedArrayConstructor = TypedArrayConstructor;
+    this.elements = new TypedArrayConstructor(initialCapacity);
+  }
+  elements;
+  length = 0;
+  add(newElement) {
+    const newLength = this.length + 1;
+    if (newLength > this.capacity) {
+      this.ensureCapacity(newLength);
+    }
+    this.elements[this.length] = newElement;
+    this.length = newLength;
+  }
+  addMany(...newElements) {
+    this.addArray(newElements);
+  }
+  addArray(newElements) {
+    const newLength = this.length + newElements.length;
+    if (newLength > this.capacity) {
+      this.ensureCapacity(newLength);
+    }
+    this.elements.set(newElements, this.length);
+    this.length = newLength;
+  }
+  ensureCapacity(requiredCapacity) {
+    if (requiredCapacity > this.capacity) {
+      const newCapacity = requiredCapacity * 2;
+      const newElements = new this.TypedArrayConstructor(newCapacity);
+      newElements.set(this.toTypedArray());
+      this.elements = newElements;
+    }
+  }
+  get capacity() {
+    return this.elements.length;
+  }
+  toTypedArray() {
+    return this.elements.subarray(0, this.length);
+  }
+  clear() {
+    this.length = 0;
+  }
+}
+function createDynamicUint8Array(initialCapacity) {
+  return new DynamicTypedArray(Uint8Array, initialCapacity);
+}
+function createDynamicUint16Array(initialCapacity) {
+  return new DynamicTypedArray(Uint16Array, initialCapacity);
+}
+async function readFileAsBinary(filePath) {
+  const chunkSize = 2 ** 20;
+  const fileInfo = await (0, import_promises.stat)(filePath);
+  const fileSize = fileInfo.size;
+  const fileReader = new FileReader(filePath);
+  const buffer = new Uint8Array(chunkSize);
+  const result = createDynamicUint8Array(fileSize);
+  while (!fileReader.isFinished) {
+    const chunk = await fileReader.readChunk(buffer);
+    result.addArray(chunk);
+  }
+  return result.toTypedArray();
+}
+class FileReader {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  fileHandle;
+  finished = false;
+  disposed = false;
+  readOffset = 0;
+  async readChunk(buffer) {
+    if (this.isDisposed) {
+      throw new Error(`FileReader has been disposed`);
+    }
+    await this.openIfNeeded();
+    let bufferWriteOffset = 0;
+    while (bufferWriteOffset < buffer.length) {
+      const remainingSizeInBuffer = buffer.length - bufferWriteOffset;
+      let bytesRead;
+      try {
+        ;
+        ({ bytesRead } = await this.fileHandle.read(buffer, {
+          offset: bufferWriteOffset,
+          length: remainingSizeInBuffer,
+          position: this.readOffset
+        }));
+      } catch (e) {
+        await this.dispose();
+        throw e;
+      }
+      if (bytesRead === 0) {
+        this.finished = true;
+        await this.dispose();
+        break;
+      }
+      bufferWriteOffset += bytesRead;
+      this.readOffset += bytesRead;
+    }
+    return buffer.subarray(0, bufferWriteOffset);
+  }
+  async openIfNeeded() {
+    if (this.isDisposed) {
+      throw new Error(`FileReader has been disposed`);
+    }
+    if (this.isOpened) {
+      return;
+    }
+    this.fileHandle = await (0, import_promises.open)(this.filePath, "r");
+  }
+  async dispose() {
+    if (this.isDisposed) {
+      return;
+    }
+    if (this.isOpened) {
+      try {
+        await this.fileHandle.close();
+      } catch (_e) {
+      }
+    }
+    this.disposed = true;
+    this.readOffset = 0;
+    this.fileHandle = void 0;
+  }
+  get isOpened() {
+    return this.fileHandle !== void 0;
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  get isFinished() {
+    return this.finished;
+  }
+}
+function encodeHex(buffer) {
+  const asciiBuffer = encodeHexAsAsciiBuffer(buffer);
+  return (0, import_Ascii.decodeAscii)(asciiBuffer);
+}
+function encodeHexAsAsciiBuffer(buffer) {
+  const bufferLen = buffer.length;
+  const charCodes = new Uint8Array(bufferLen * 2);
+  let readOffset = 0;
+  let writeOffset = 0;
+  while (readOffset < bufferLen) {
+    const value = buffer[readOffset++];
+    if (value === void 0) {
+      throw new Error(`buffer value at offset ${readOffset - 1} not found`);
+    }
+    const valueHigh4Bits = value >>> 4 & 15;
+    const valueLow4Bits = value & 15;
+    const highCharCode = hexCharCodeLookup[valueHigh4Bits];
+    const lowCharCode = hexCharCodeLookup[valueLow4Bits];
+    if (highCharCode === void 0 || lowCharCode === void 0) {
+      throw new Error(`hex char code lookup failed for value ${value}`);
+    }
+    charCodes[writeOffset++] = highCharCode;
+    charCodes[writeOffset++] = lowCharCode;
+  }
+  return charCodes;
+}
+function decodeHex(hexString) {
+  const hexLength = hexString.length;
+  if (hexLength % 2 !== 0) {
+    throw new Error(
+      `Hexadecimal string doesn't have an even number of characters`
+    );
+  }
+  const buffer = new Uint8Array(hexLength / 2);
+  let readOffset = 0;
+  let writeOffset = 0;
+  while (readOffset < hexLength) {
+    const valueHigh4Bits = hexCharCodeToValue(
+      hexString.charCodeAt(readOffset++)
+    );
+    const valueLow4Bits = hexCharCodeToValue(hexString.charCodeAt(readOffset++));
+    const value = valueHigh4Bits << 4 | valueLow4Bits;
+    buffer[writeOffset++] = value;
+  }
+  return buffer;
+}
+function hexCharCodeToValue(hexCharCode) {
+  if (hexCharCode >= 48 && hexCharCode <= 57) {
+    return hexCharCode - 48;
+  } else if (hexCharCode >= 97 && hexCharCode <= 102) {
+    return 10 + hexCharCode - 97;
+  } else if (hexCharCode >= 65 && hexCharCode <= 70) {
+    return 10 + hexCharCode - 65;
+  } else {
+    throw new Error(
+      `Can't decode character '${String.fromCharCode(hexCharCode)}' (code: ${hexCharCode}) as hexadecimal`
+    );
+  }
+}
+const hexCharCodeLookup = new Uint8Array([
+  48,
+  49,
+  50,
+  51,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  97,
+  98,
+  99,
+  100,
+  101,
+  102
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDynamicUint16Array,
+  detectVoiceActivity
+});