@buffered-audio/nodes 0.18.2 → 0.20.0

package/dist/chunk-YJWZP2OD.js

@@ -0,0 +1,2067 @@
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var AmplitudeHistogramAccumulator = class {
+  constructor(bucketCount) {
+    this.bucketMax = 0;
+    this.totalSamples = 0;
+    this.pendingZeros = 0;
+    this.finalized = false;
+    if (!Number.isInteger(bucketCount) || bucketCount <= 0) {
+      throw new Error(`AmplitudeHistogramAccumulator: bucketCount must be a positive integer, got ${String(bucketCount)}`);
+    }
+    this.bucketCount = bucketCount;
+    this.buckets = new Uint32Array(bucketCount);
+  }
+  // Consumes `frames` samples per channel; throws if any channel has fewer than `frames` samples or if `finalize` was already called.
+  push(channels, frames) {
+    if (this.finalized) {
+      throw new Error("AmplitudeHistogramAccumulator: push() called after finalize()");
+    }
+    if (frames <= 0) return;
+    for (let channelIndex = 0; channelIndex < channels.length; channelIndex++) {
+      const channel = channels[channelIndex];
+      if (channel === void 0 || channel.length < frames) {
+        throw new Error(`AmplitudeHistogramAccumulator: channel ${channelIndex} has ${channel?.length ?? 0} samples, fewer than the requested ${frames}`);
+      }
+    }
+    let chunkMax = 0;
+    for (const channel of channels) {
+      for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+        const value = Math.abs(channel[frameIndex] ?? 0);
+        if (value > chunkMax) chunkMax = value;
+      }
+    }
+    if (chunkMax > this.bucketMax) {
+      this.rebucket(chunkMax);
+    }
+    if (this.bucketMax === 0) {
+      const chunkSamples = channels.length * frames;
+      this.pendingZeros += chunkSamples;
+      this.totalSamples += chunkSamples;
+      return;
+    }
+    const scale = this.bucketCount / this.bucketMax;
+    const lastBucket = this.bucketCount - 1;
+    for (const channel of channels) {
+      for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+        const value = Math.abs(channel[frameIndex] ?? 0);
+        let bucketIndex = Math.floor(value * scale);
+        if (bucketIndex < 0) bucketIndex = 0;
+        else if (bucketIndex > lastBucket) bucketIndex = lastBucket;
+        this.buckets[bucketIndex] = (this.buckets[bucketIndex] ?? 0) + 1;
+        this.totalSamples += 1;
+      }
+    }
+  }
+  finalize() {
+    if (this.cachedResult !== void 0) return this.cachedResult;
+    this.finalized = true;
+    if (this.totalSamples === 0 || this.bucketMax === 0) {
+      this.cachedResult = { buckets: this.buckets, bucketMax: 0, median: 0 };
+      return this.cachedResult;
+    }
+    const target = this.totalSamples / 2;
+    const bucketWidth = this.bucketMax / this.bucketCount;
+    let cumulative = 0;
+    let median = 0;
+    for (let bucketIndex = 0; bucketIndex < this.bucketCount; bucketIndex++) {
+      const count = this.buckets[bucketIndex] ?? 0;
+      const next = cumulative + count;
+      if (next >= target) {
+        const fraction = count > 0 ? (target - cumulative) / count : 0;
+        median = (bucketIndex + fraction) * bucketWidth;
+        break;
+      }
+      cumulative = next;
+    }
+    this.cachedResult = { buckets: this.buckets, bucketMax: this.bucketMax, median };
+    return this.cachedResult;
+  }
+  rebucket(newMax) {
+    if (this.bucketMax === 0) {
+      if (this.pendingZeros > 0) {
+        this.buckets[0] = (this.buckets[0] ?? 0) + this.pendingZeros;
+        this.pendingZeros = 0;
+      }
+      this.bucketMax = newMax;
+      return;
+    }
+    const oldBuckets = this.buckets;
+    const oldMax = this.bucketMax;
+    const newBuckets = new Uint32Array(this.bucketCount);
+    const lastBucket = this.bucketCount - 1;
+    const oldWidth = oldMax / this.bucketCount;
+    const newScale = this.bucketCount / newMax;
+    for (let oldIndex = 0; oldIndex < this.bucketCount; oldIndex++) {
+      const count = oldBuckets[oldIndex] ?? 0;
+      if (count === 0) continue;
+      const center = (oldIndex + 0.5) * oldWidth;
+      let newIndex = Math.floor(center * newScale);
+      if (newIndex < 0) newIndex = 0;
+      else if (newIndex > lastBucket) newIndex = lastBucket;
+      newBuckets[newIndex] = (newBuckets[newIndex] ?? 0) + count;
+    }
+    this.buckets = newBuckets;
+    this.bucketMax = newMax;
+  }
+};
+function zeroPhaseBiquadFilter(signal, coefficients) {
+  const { fb, fa } = coefficients;
+  let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+  for (let index = 0; index < signal.length; index++) {
+    const x0 = signal[index] ?? 0;
+    const y0 = fb[0] * x0 + fb[1] * x1 + fb[2] * x2 - fa[1] * y1 - fa[2] * y2;
+    signal[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  x1 = 0;
+  x2 = 0;
+  y1 = 0;
+  y2 = 0;
+  for (let index = signal.length - 1; index >= 0; index--) {
+    const x0 = signal[index] ?? 0;
+    const y0 = fb[0] * x0 + fb[1] * x1 + fb[2] * x2 - fa[1] * y1 - fa[2] * y2;
+    signal[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+}
+function lowPassCoefficients(sampleRate, frequency, quality = Math.SQRT1_2) {
+  const w0 = 2 * Math.PI * frequency / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const sinW0 = Math.sin(w0);
+  const alpha = sinW0 / (2 * quality);
+  const a0 = 1 + alpha;
+  return {
+    fb: [(1 - cosW0) / 2 / a0, (1 - cosW0) / a0, (1 - cosW0) / 2 / a0],
+    fa: [1, -2 * cosW0 / a0, (1 - alpha) / a0]
+  };
+}
+function highPassCoefficients(sampleRate, frequency, quality = Math.SQRT1_2) {
+  const w0 = 2 * Math.PI * frequency / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const sinW0 = Math.sin(w0);
+  const alpha = sinW0 / (2 * quality);
+  const a0 = 1 + alpha;
+  return {
+    fb: [(1 + cosW0) / 2 / a0, -(1 + cosW0) / a0, (1 + cosW0) / 2 / a0],
+    fa: [1, -2 * cosW0 / a0, (1 - alpha) / a0]
+  };
+}
+function preFilterCoefficients(sampleRate) {
+  if (sampleRate === 48e3) {
+    return {
+      fb: [1.53512485958697, -2.69169618940638, 1.19839281085285],
+      fa: [1, -1.69065929318241, 0.73248077421585]
+    };
+  }
+  const freq = 1681.974450955533;
+  const gain = 3.999843853973347;
+  const quality = 0.7071752369554196;
+  const kk = Math.tan(Math.PI * freq / sampleRate);
+  const vh = Math.pow(10, gain / 20);
+  const vb = Math.pow(vh, 0.4996667741545416);
+  const a0 = 1 + kk / quality + kk * kk;
+  return {
+    fb: [(vh + vb * kk / quality + kk * kk) / a0, 2 * (kk * kk - vh) / a0, (vh - vb * kk / quality + kk * kk) / a0],
+    fa: [1, 2 * (kk * kk - 1) / a0, (1 - kk / quality + kk * kk) / a0]
+  };
+}
+function rlbFilterCoefficients(sampleRate) {
+  if (sampleRate === 48e3) {
+    return {
+      fb: [1, -2, 1],
+      fa: [1, -1.99004745483398, 0.99007225036621]
+    };
+  }
+  const freq = 38.13547087602444;
+  const quality = 0.5003270373238773;
+  const kk = Math.tan(Math.PI * freq / sampleRate);
+  const a0 = 1 + kk / quality + kk * kk;
+  return {
+    fb: [1 / a0, -2 / a0, 1 / a0],
+    fa: [1, 2 * (kk * kk - 1) / a0, (1 - kk / quality + kk * kk) / a0]
+  };
+}
+function bandpass(channels, sampleRate, highPass, lowPass) {
+  if (!highPass && !lowPass) return;
+  for (const channel of channels) {
+    if (highPass) {
+      zeroPhaseBiquadFilter(channel, highPassCoefficients(sampleRate, highPass));
+    }
+    if (lowPass) {
+      zeroPhaseBiquadFilter(channel, lowPassCoefficients(sampleRate, lowPass));
+    }
+  }
+}
+var BidirectionalIir = class {
+  constructor(options) {
+    this.smoothingMs = options.smoothingMs;
+    this.sampleRate = options.sampleRate;
+    const samplePeriod = 1 / this.sampleRate;
+    const tauBidirectional = this.smoothingMs / 1e3 * Math.SQRT2;
+    this.alphaBidirectional = tauBidirectional > 0 ? 1 - Math.exp(-samplePeriod / tauBidirectional) : 1;
+    const tauCausal = this.smoothingMs / 1e3;
+    this.alphaCausal = tauCausal > 0 ? 1 - Math.exp(-samplePeriod / tauCausal) : 1;
+  }
+  applyBidirectional(input) {
+    const output = Float32Array.from(input);
+    if (this.smoothingMs <= 0) return output;
+    const alpha = this.alphaBidirectional;
+    const oneMinusAlpha = 1 - alpha;
+    let y = output[0] ?? 0;
+    for (let index = 0; index < output.length; index++) {
+      const x = output[index] ?? 0;
+      y = alpha * x + oneMinusAlpha * y;
+      output[index] = y;
+    }
+    y = output[output.length - 1] ?? 0;
+    for (let index = output.length - 1; index >= 0; index--) {
+      const x = output[index] ?? 0;
+      y = alpha * x + oneMinusAlpha * y;
+      output[index] = y;
+    }
+    return output;
+  }
+  applyCausal(input, state) {
+    const output = Float32Array.from(input);
+    if (this.smoothingMs <= 0) return output;
+    const alpha = this.alphaCausal;
+    const oneMinusAlpha = 1 - alpha;
+    let y = state.value;
+    for (let index = 0; index < output.length; index++) {
+      const x = output[index] ?? 0;
+      y = alpha * x + oneMinusAlpha * y;
+      output[index] = y;
+    }
+    state.value = y;
+    return output;
+  }
+  applyForwardPass(input, state) {
+    const output = Float32Array.from(input);
+    if (this.smoothingMs <= 0) return output;
+    const alpha = this.alphaBidirectional;
+    const oneMinusAlpha = 1 - alpha;
+    let y = state.value;
+    for (let index = 0; index < output.length; index++) {
+      const x = output[index] ?? 0;
+      y = alpha * x + oneMinusAlpha * y;
+      output[index] = y;
+    }
+    state.value = y;
+    return output;
+  }
+  applyBackwardPassInPlace(buffer) {
+    if (this.smoothingMs <= 0) return;
+    if (buffer.length === 0) return;
+    const alpha = this.alphaBidirectional;
+    const oneMinusAlpha = 1 - alpha;
+    let y = buffer[buffer.length - 1] ?? 0;
+    for (let index = buffer.length - 1; index >= 0; index--) {
+      const x = buffer[index] ?? 0;
+      y = alpha * x + oneMinusAlpha * y;
+      buffer[index] = y;
+    }
+  }
+};
+var computeRingSize = (blockSize, blockStep) => Math.max(1, Math.ceil(blockSize / blockStep));
+var BlockSumAccumulator = class {
+  constructor(blockSize, blockStep) {
+    this.closedBlockSums = [];
+    this.samplesProcessed = 0;
+    this.nextBlockToOpen = 0;
+    this.nextBlockToClose = 0;
+    this.finalized = false;
+    if (blockSize <= 0) {
+      throw new Error(`BlockSumAccumulator: blockSize must be positive, got ${blockSize}`);
+    }
+    if (blockStep <= 0) {
+      throw new Error(`BlockSumAccumulator: blockStep must be positive, got ${blockStep}`);
+    }
+    this.blockSize = blockSize;
+    this.blockStep = blockStep;
+    this.ringSize = computeRingSize(blockSize, blockStep);
+    this.activeBlockSums = new Float64Array(this.ringSize);
+  }
+  // Consumes `frames` per-frame sums from `perFrameSums[0]` (needs length >= `frames`); block-boundary accounting advances as if appended to one contiguous stream.
+  push(perFrameSums, frames) {
+    if (this.finalized) {
+      throw new Error("BlockSumAccumulator: push() called after finalize()");
+    }
+    if (frames <= 0) return;
+    if (perFrameSums.length < frames) {
+      throw new Error(`BlockSumAccumulator: perFrameSums has ${perFrameSums.length} entries, fewer than the requested ${frames}`);
+    }
+    const blockSize = this.blockSize;
+    const blockStep = this.blockStep;
+    const ringSize = this.ringSize;
+    const activeBlockSums = this.activeBlockSums;
+    let samplesProcessed = this.samplesProcessed;
+    let nextBlockToOpen = this.nextBlockToOpen;
+    let nextBlockToClose = this.nextBlockToClose;
+    let nextOpenAt = nextBlockToOpen * blockStep;
+    let nextCloseAt = nextBlockToClose * blockStep + blockSize;
+    for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+      const sampleContribution = perFrameSums[frameIndex] ?? 0;
+      while (samplesProcessed >= nextOpenAt) {
+        activeBlockSums[nextBlockToOpen % ringSize] = 0;
+        nextBlockToOpen++;
+        nextOpenAt += blockStep;
+      }
+      let slot = nextBlockToClose % ringSize;
+      for (let blockIndex = nextBlockToClose; blockIndex < nextBlockToOpen; blockIndex++) {
+        activeBlockSums[slot] = (activeBlockSums[slot] ?? 0) + sampleContribution;
+        slot++;
+        if (slot === ringSize) slot = 0;
+      }
+      samplesProcessed++;
+      while (samplesProcessed >= nextCloseAt) {
+        this.closedBlockSums.push(activeBlockSums[nextBlockToClose % ringSize] ?? 0);
+        nextBlockToClose++;
+        nextCloseAt += blockStep;
+      }
+    }
+    this.samplesProcessed = samplesProcessed;
+    this.nextBlockToOpen = nextBlockToOpen;
+    this.nextBlockToClose = nextBlockToClose;
+  }
+  finalize() {
+    this.finalized = true;
+    return this.closedBlockSums;
+  }
+};
+function dbToLinear(db) {
+  if (db === -Infinity) return 0;
+  return Math.pow(10, db / 20);
+}
+function linearToDb(linear) {
+  return 20 * Math.log10(Math.max(linear, 1e-10));
+}
+var require2 = createRequire(import.meta.url);
+function tryLoadVkfft(vkfftPath) {
+  if (!vkfftPath) return null;
+  try {
+    return require2(vkfftPath);
+  } catch {
+    return null;
+  }
+}
+function tryLoadFftw(fftwPath) {
+  if (!fftwPath) return null;
+  try {
+    return require2(fftwPath);
+  } catch {
+    return null;
+  }
+}
+function detectFftBackend(executionProviders, options) {
+  for (const provider of executionProviders) {
+    if (provider === "gpu") {
+      const vkfft = tryLoadVkfft(options?.vkfftPath);
+      if (vkfft) {
+        const device = vkfft.detectDevice();
+        if (device) {
+          return "vkfft";
+        }
+      }
+    }
+    if (provider === "cpu-native") {
+      const fftw = tryLoadFftw(options?.fftwPath);
+      if (fftw) {
+        return "fftw";
+      }
+    }
+    if (provider === "cpu") {
+      return "js";
+    }
+  }
+  return "js";
+}
+function initFftBackend(executionProviders, properties) {
+  const addonOptions = { vkfftPath: properties.vkfftAddonPath, fftwPath: properties.fftwAddonPath };
+  const backend = detectFftBackend(executionProviders, addonOptions);
+  return { backend, addonOptions };
+}
+function getFftAddon(backend, options) {
+  if (backend === "vkfft") return tryLoadVkfft(options?.vkfftPath);
+  if (backend === "fftw") return tryLoadFftw(options?.fftwPath);
+  return null;
+}
+function interleave(samples, frames, channels) {
+  const interleaved = new Float32Array(frames * channels);
+  for (let frame = 0; frame < frames; frame++) {
+    for (let ch = 0; ch < channels; ch++) {
+      interleaved[frame * channels + ch] = samples[ch]?.[frame] ?? 0;
+    }
+  }
+  return interleaved;
+}
+function deinterleaveBuffer(buffer, channels) {
+  const totalSamples = buffer.length / 4;
+  const frames = Math.floor(totalSamples / channels);
+  const result = [];
+  for (let ch = 0; ch < channels; ch++) {
+    result.push(new Float32Array(frames));
+  }
+  const view = new Float32Array(buffer.buffer, buffer.byteOffset, totalSamples);
+  for (let frame = 0; frame < frames; frame++) {
+    for (let ch = 0; ch < channels; ch++) {
+      const channelArray = result[ch];
+      const value = view[frame * channels + ch];
+      if (channelArray && value !== void 0) {
+        channelArray[frame] = value;
+      }
+    }
+  }
+  return result;
+}
+var KWeightedSquaredSum = class {
+  constructor(sampleRate, channelCount, channelWeights) {
+    if (channelCount <= 0) {
+      throw new Error(`KWeightedSquaredSum: channelCount must be positive, got ${channelCount}`);
+    }
+    const weights = channelWeights ?? new Array(channelCount).fill(1);
+    if (weights.length !== channelCount) {
+      throw new Error(`KWeightedSquaredSum: channelWeights length ${weights.length} does not match channel count ${channelCount}`);
+    }
+    this.channelCount = channelCount;
+    const preFilter = preFilterCoefficients(sampleRate);
+    const rlbFilter = rlbFilterCoefficients(sampleRate);
+    this.preB0 = preFilter.fb[0];
+    this.preB1 = preFilter.fb[1];
+    this.preB2 = preFilter.fb[2];
+    this.preA1 = preFilter.fa[1];
+    this.preA2 = preFilter.fa[2];
+    this.rlbB0 = rlbFilter.fb[0];
+    this.rlbB1 = rlbFilter.fb[1];
+    this.rlbB2 = rlbFilter.fb[2];
+    this.rlbA1 = rlbFilter.fa[1];
+    this.rlbA2 = rlbFilter.fa[2];
+    this.preX1 = new Float64Array(channelCount);
+    this.preX2 = new Float64Array(channelCount);
+    this.preY1 = new Float64Array(channelCount);
+    this.preY2 = new Float64Array(channelCount);
+    this.rlbX1 = new Float64Array(channelCount);
+    this.rlbX2 = new Float64Array(channelCount);
+    this.rlbY1 = new Float64Array(channelCount);
+    this.rlbY2 = new Float64Array(channelCount);
+    this.weights = new Float64Array(channelCount);
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      this.weights[channelIndex] = weights[channelIndex] ?? 1;
+    }
+  }
+  // `channels[c]` and `output` need >= `frames` entries from index 0 (oversized OK); `output[i]` gets the K-weighted channel-weighted squared sum at frame `i`; biquad state advances as if appended contiguously.
+  push(channels, frames, output) {
+    if (channels.length !== this.channelCount) {
+      throw new Error(`KWeightedSquaredSum: push got ${channels.length} channels, expected ${this.channelCount}`);
+    }
+    if (frames <= 0) return;
+    for (let channelIndex = 0; channelIndex < this.channelCount; channelIndex++) {
+      const channel = channels[channelIndex] ?? new Float32Array(0);
+      if (channel.length < frames) {
+        throw new Error(`KWeightedSquaredSum: channel ${channelIndex} has ${channel.length} samples, fewer than the requested ${frames}`);
+      }
+    }
+    if (output.length < frames) {
+      throw new Error(`KWeightedSquaredSum: output buffer has ${output.length} entries, fewer than the requested ${frames}`);
+    }
+    const channelCount = this.channelCount;
+    const weights = this.weights;
+    const preB0 = this.preB0;
+    const preB1 = this.preB1;
+    const preB2 = this.preB2;
+    const preA1 = this.preA1;
+    const preA2 = this.preA2;
+    const rlbB0 = this.rlbB0;
+    const rlbB1 = this.rlbB1;
+    const rlbB2 = this.rlbB2;
+    const rlbA1 = this.rlbA1;
+    const rlbA2 = this.rlbA2;
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      const channel = channels[channelIndex] ?? channels[0] ?? new Float32Array(0);
+      const weight = weights[channelIndex] ?? 1;
+      let px1 = this.preX1[channelIndex] ?? 0;
+      let px2 = this.preX2[channelIndex] ?? 0;
+      let py1 = this.preY1[channelIndex] ?? 0;
+      let py2 = this.preY2[channelIndex] ?? 0;
+      let rx1 = this.rlbX1[channelIndex] ?? 0;
+      let rx2 = this.rlbX2[channelIndex] ?? 0;
+      let ry1 = this.rlbY1[channelIndex] ?? 0;
+      let ry2 = this.rlbY2[channelIndex] ?? 0;
+      if (channelIndex === 0) {
+        for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+          const x0 = channel[frameIndex] ?? 0;
+          const preY = preB0 * x0 + preB1 * px1 + preB2 * px2 - preA1 * py1 - preA2 * py2;
+          px2 = px1;
+          px1 = x0;
+          py2 = py1;
+          py1 = preY;
+          const rlbY = rlbB0 * preY + rlbB1 * rx1 + rlbB2 * rx2 - rlbA1 * ry1 - rlbA2 * ry2;
+          rx2 = rx1;
+          rx1 = preY;
+          ry2 = ry1;
+          ry1 = rlbY;
+          output[frameIndex] = weight * rlbY * rlbY;
+        }
+      } else {
+        for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+          const x0 = channel[frameIndex] ?? 0;
+          const preY = preB0 * x0 + preB1 * px1 + preB2 * px2 - preA1 * py1 - preA2 * py2;
+          px2 = px1;
+          px1 = x0;
+          py2 = py1;
+          py1 = preY;
+          const rlbY = rlbB0 * preY + rlbB1 * rx1 + rlbB2 * rx2 - rlbA1 * ry1 - rlbA2 * ry2;
+          rx2 = rx1;
+          rx1 = preY;
+          ry2 = ry1;
+          ry1 = rlbY;
+          output[frameIndex] = (output[frameIndex] ?? 0) + weight * rlbY * rlbY;
+        }
+      }
+      this.preX1[channelIndex] = px1;
+      this.preX2[channelIndex] = px2;
+      this.preY1[channelIndex] = py1;
+      this.preY2[channelIndex] = py2;
+      this.rlbX1[channelIndex] = rx1;
+      this.rlbX2[channelIndex] = rx2;
+      this.rlbY1[channelIndex] = ry1;
+      this.rlbY2[channelIndex] = ry2;
+    }
+  }
+};
+var LUFS_OFFSET = -0.691;
+var ABSOLUTE_GATE_LUFS = -70;
+var RELATIVE_GATE_OFFSET_LU = -10;
+var BLOCK_DURATION_SECONDS = 0.4;
+var BLOCK_STEP_SECONDS = 0.1;
+var SHORT_TERM_BLOCK_DURATION_SECONDS = 3;
+var POWER_FLOOR = 1e-10;
+var LRA_ABSOLUTE_GATE_LUFS = -70;
+var LRA_RELATIVE_GATE_OFFSET_LU = -20;
+var LRA_LOW_PERCENTILE = 0.1;
+var LRA_HIGH_PERCENTILE = 0.95;
+function applyBs1770Gating(closedBlockSums, blockSize) {
+  const blockCount = closedBlockSums.length;
+  if (blockCount === 0) return -Infinity;
+  const absoluteThresholdPower = Math.pow(10, (ABSOLUTE_GATE_LUFS - LUFS_OFFSET) / 10);
+  let absoluteSurvivorCount = 0;
+  let absoluteSum = 0;
+  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+    const power = (closedBlockSums[blockIndex] ?? 0) / blockSize;
+    if (power > absoluteThresholdPower) {
+      absoluteSum += power;
+      absoluteSurvivorCount++;
+    }
+  }
+  if (absoluteSurvivorCount === 0) return -Infinity;
+  const absoluteMean = absoluteSum / absoluteSurvivorCount;
+  const relativeThresholdLufs = LUFS_OFFSET + 10 * Math.log10(absoluteMean) + RELATIVE_GATE_OFFSET_LU;
+  const relativeThresholdPower = Math.pow(10, (relativeThresholdLufs - LUFS_OFFSET) / 10);
+  let relativeSurvivorCount = 0;
+  let relativeSum = 0;
+  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+    const power = (closedBlockSums[blockIndex] ?? 0) / blockSize;
+    if (power > absoluteThresholdPower && power > relativeThresholdPower) {
+      relativeSum += power;
+      relativeSurvivorCount++;
+    }
+  }
+  if (relativeSurvivorCount === 0) return -Infinity;
+  const integratedMean = relativeSum / relativeSurvivorCount;
+  return LUFS_OFFSET + 10 * Math.log10(integratedMean);
+}
+var IntegratedLufsAccumulator = class {
+  constructor(sampleRate, channelCount, channelWeights) {
+    this.outputBuffer = new Float64Array(0);
+    this.finalized = false;
+    if (channelCount <= 0) {
+      throw new Error(`IntegratedLufsAccumulator: channelCount must be positive, got ${channelCount}`);
+    }
+    if (channelWeights !== void 0 && channelWeights.length !== channelCount) {
+      throw new Error(`IntegratedLufsAccumulator: channelWeights length ${channelWeights.length} does not match channel count ${channelCount}`);
+    }
+    this.blockSize = Math.round(BLOCK_DURATION_SECONDS * sampleRate);
+    const blockStep = Math.round(BLOCK_STEP_SECONDS * sampleRate);
+    this.kw = new KWeightedSquaredSum(sampleRate, channelCount, channelWeights);
+    this.blocks = new BlockSumAccumulator(this.blockSize, blockStep);
+  }
+  // `channels[c]` needs >= `frames` valid samples from index 0 (oversized OK); state advances as if appended to one contiguous buffer.
+  push(channels, frames) {
+    if (this.finalized) {
+      throw new Error("IntegratedLufsAccumulator: push() called after finalize()");
+    }
+    if (frames <= 0) return;
+    if (this.outputBuffer.length < frames) {
+      this.outputBuffer = new Float64Array(frames);
+    }
+    this.kw.push(channels, frames, this.outputBuffer);
+    this.blocks.push(this.outputBuffer, frames);
+  }
+  finalize() {
+    this.finalized = true;
+    return applyBs1770Gating(this.blocks.finalize(), this.blockSize);
+  }
+};
+function computeLraFromShortTerm(shortTermLoudness) {
+  const absoluteGated = [];
+  for (let index = 0; index < shortTermLoudness.length; index++) {
+    const value = shortTermLoudness[index] ?? 0;
+    if (value > LRA_ABSOLUTE_GATE_LUFS) {
+      absoluteGated.push(value);
+    }
+  }
+  if (absoluteGated.length < 2) return 0;
+  let absoluteSum = 0;
+  for (let index = 0; index < absoluteGated.length; index++) {
+    absoluteSum += Math.pow(10, (absoluteGated[index] ?? 0) / 10);
+  }
+  const absoluteMean = absoluteSum / absoluteGated.length;
+  const relativeThreshold = 10 * Math.log10(absoluteMean) + LRA_RELATIVE_GATE_OFFSET_LU;
+  const relativeGated = [];
+  for (let index = 0; index < absoluteGated.length; index++) {
+    const value = absoluteGated[index] ?? 0;
+    if (value > relativeThreshold) {
+      relativeGated.push(value);
+    }
+  }
+  if (relativeGated.length < 2) return 0;
+  relativeGated.sort((lhs, rhs) => lhs - rhs);
+  const lowIndex = Math.floor(relativeGated.length * LRA_LOW_PERCENTILE);
+  const highIndex = Math.min(Math.ceil(relativeGated.length * LRA_HIGH_PERCENTILE) - 1, relativeGated.length - 1);
+  return (relativeGated[highIndex] ?? 0) - (relativeGated[lowIndex] ?? 0);
+}
+function getLraConsideredStats(shortTerm) {
+  const aboveAbsolute = [];
+  for (let index = 0; index < shortTerm.length; index++) {
+    const lufs = shortTerm[index] ?? 0;
+    if (lufs > LRA_ABSOLUTE_GATE_LUFS) {
+      aboveAbsolute.push(lufs);
+    }
+  }
+  if (aboveAbsolute.length === 0) {
+    return { min: Number.POSITIVE_INFINITY, median: Number.POSITIVE_INFINITY };
+  }
+  let absoluteSum = 0;
+  for (let index = 0; index < aboveAbsolute.length; index++) {
+    absoluteSum += Math.pow(10, (aboveAbsolute[index] ?? 0) / 10);
+  }
+  const absoluteMean = absoluteSum / aboveAbsolute.length;
+  const relativeThreshold = 10 * Math.log10(absoluteMean) + LRA_RELATIVE_GATE_OFFSET_LU;
+  const considered = [];
+  for (let index = 0; index < aboveAbsolute.length; index++) {
+    const lufs = aboveAbsolute[index] ?? 0;
+    if (lufs > relativeThreshold) {
+      considered.push(lufs);
+    }
+  }
+  if (considered.length === 0) {
+    return { min: Number.POSITIVE_INFINITY, median: Number.POSITIVE_INFINITY };
+  }
+  considered.sort((left, right) => left - right);
+  const min = considered[0] ?? Number.POSITIVE_INFINITY;
+  const middleIndex = considered.length >> 1;
+  const median = considered.length % 2 === 1 ? considered[middleIndex] ?? Number.POSITIVE_INFINITY : ((considered[middleIndex - 1] ?? 0) + (considered[middleIndex] ?? 0)) / 2;
+  return { min, median };
+}
+var LoudnessAccumulator = class {
+  constructor(sampleRate, channelCount, channelWeights) {
+    this.outputBuffer = new Float64Array(0);
+    this.finalized = false;
+    if (channelCount <= 0) {
+      throw new Error(`LoudnessAccumulator: channelCount must be positive, got ${channelCount}`);
+    }
+    if (channelWeights !== void 0 && channelWeights.length !== channelCount) {
+      throw new Error(`LoudnessAccumulator: channelWeights length ${channelWeights.length} does not match channel count ${channelCount}`);
+    }
+    this.blockSize400 = Math.round(BLOCK_DURATION_SECONDS * sampleRate);
+    this.blockSize3s = Math.round(SHORT_TERM_BLOCK_DURATION_SECONDS * sampleRate);
+    const blockStep = Math.round(BLOCK_STEP_SECONDS * sampleRate);
+    this.kw = new KWeightedSquaredSum(sampleRate, channelCount, channelWeights);
+    this.blocks400 = new BlockSumAccumulator(this.blockSize400, blockStep);
+    this.blocks3s = new BlockSumAccumulator(this.blockSize3s, blockStep);
+  }
+  push(channels, frames) {
+    if (this.finalized) {
+      throw new Error("LoudnessAccumulator: push() called after finalize()");
+    }
+    if (frames <= 0) return;
+    if (this.outputBuffer.length < frames) {
+      this.outputBuffer = new Float64Array(frames);
+    }
+    this.kw.push(channels, frames, this.outputBuffer);
+    this.blocks400.push(this.outputBuffer, frames);
+    this.blocks3s.push(this.outputBuffer, frames);
+  }
+  finalize() {
+    if (this.cachedResult !== void 0) return this.cachedResult;
+    this.finalized = true;
+    const closed400 = this.blocks400.finalize();
+    const closed3s = this.blocks3s.finalize();
+    const blockSize400 = this.blockSize400;
+    const blockSize3s = this.blockSize3s;
+    const momentary = new Array(closed400.length);
+    for (let index = 0; index < closed400.length; index++) {
+      const sum = closed400[index] ?? 0;
+      momentary[index] = LUFS_OFFSET + 10 * Math.log10(Math.max(sum / blockSize400, POWER_FLOOR));
+    }
+    const shortTerm = new Array(closed3s.length);
+    for (let index = 0; index < closed3s.length; index++) {
+      const sum = closed3s[index] ?? 0;
+      shortTerm[index] = LUFS_OFFSET + 10 * Math.log10(Math.max(sum / blockSize3s, POWER_FLOOR));
+    }
+    const integrated = applyBs1770Gating(closed400, blockSize400);
+    const range = computeLraFromShortTerm(shortTerm);
+    this.cachedResult = { integrated, momentary, shortTerm, range };
+    return this.cachedResult;
+  }
+};
+var MixedRadixFft = class {
+  constructor(size) {
+    this.size = size;
+    this.radices = factorize(size);
+    this.frameRe = new Float32Array(size);
+    this.frameIm = new Float32Array(size);
+    this.outRe = new Float32Array(size);
+    this.outIm = new Float32Array(size);
+    this.auxIm = new Float32Array(size);
+    this.permutation = computePermutation(size, this.radices);
+    const { twiddleRe, twiddleIm } = computeTwiddles(this.radices);
+    this.twiddleRe = twiddleRe;
+    this.twiddleIm = twiddleIm;
+  }
+  fft(xRe, xIm, outRe, outIm) {
+    const perm = this.permutation;
+    const nn = this.size;
+    for (let index = 0; index < nn; index++) {
+      const pp = perm[index] ?? 0;
+      outRe[index] = xRe[pp] ?? 0;
+      outIm[index] = xIm[pp] ?? 0;
+    }
+    let groupSize = 1;
+    let twOffset = 0;
+    for (const radix of this.radices) {
+      groupSize *= radix;
+      const subSize = groupSize / radix;
+      if (radix === 2) {
+        twOffset = this.radix2(outRe, outIm, nn, groupSize, subSize, twOffset);
+      } else if (radix === 3) {
+        twOffset = this.radix3(outRe, outIm, nn, groupSize, subSize, twOffset);
+      } else if (radix === 5) {
+        twOffset = this.radix5(outRe, outIm, nn, groupSize, subSize, twOffset);
+      }
+    }
+  }
+  ifft(xRe, xIm, outRe, outIm) {
+    const auxIm = this.auxIm;
+    const nn = this.size;
+    for (let index = 0; index < nn; index++) {
+      auxIm[index] = -(xIm[index] ?? 0);
+    }
+    this.fft(xRe, auxIm, outRe, outIm);
+    for (let index = 0; index < nn; index++) {
+      outRe[index] = (outRe[index] ?? 0) / nn;
+      outIm[index] = -(outIm[index] ?? 0) / nn;
+    }
+  }
+  radix2(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const twRe = ni === 0 ? 1 : this.twiddleRe[twOffset + ni - 1] ?? 0;
+        const twIm = ni === 0 ? 0 : this.twiddleIm[twOffset + ni - 1] ?? 0;
+        const tRe = (outRe[idx1] ?? 0) * twRe - (outIm[idx1] ?? 0) * twIm;
+        const tIm = (outRe[idx1] ?? 0) * twIm + (outIm[idx1] ?? 0) * twRe;
+        outRe[idx1] = (outRe[idx0] ?? 0) - tRe;
+        outIm[idx1] = (outIm[idx0] ?? 0) - tIm;
+        outRe[idx0] = (outRe[idx0] ?? 0) + tRe;
+        outIm[idx0] = (outIm[idx0] ?? 0) + tIm;
+      }
+    }
+    return twOffset + subSize - 1;
+  }
+  radix3(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    const c3 = -0.5;
+    const s3 = -Math.sqrt(3) / 2;
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const idx2 = idx0 + 2 * subSize;
+        let tw1Re, tw1Im, tw2Re, tw2Im;
+        if (ni === 0) {
+          tw1Re = 1;
+          tw1Im = 0;
+          tw2Re = 1;
+          tw2Im = 0;
+        } else {
+          tw1Re = this.twiddleRe[twOffset + ni - 1] ?? 0;
+          tw1Im = this.twiddleIm[twOffset + ni - 1] ?? 0;
+          tw2Re = this.twiddleRe[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw2Im = this.twiddleIm[twOffset + subSize - 1 + ni - 1] ?? 0;
+        }
+        const x1Re = (outRe[idx1] ?? 0) * tw1Re - (outIm[idx1] ?? 0) * tw1Im;
+        const x1Im = (outRe[idx1] ?? 0) * tw1Im + (outIm[idx1] ?? 0) * tw1Re;
+        const x2Re = (outRe[idx2] ?? 0) * tw2Re - (outIm[idx2] ?? 0) * tw2Im;
+        const x2Im = (outRe[idx2] ?? 0) * tw2Im + (outIm[idx2] ?? 0) * tw2Re;
+        const x0Re = outRe[idx0] ?? 0;
+        const x0Im = outIm[idx0] ?? 0;
+        const sumRe = x1Re + x2Re;
+        const sumIm = x1Im + x2Im;
+        const diffRe = x1Re - x2Re;
+        const diffIm = x1Im - x2Im;
+        outRe[idx0] = x0Re + sumRe;
+        outIm[idx0] = x0Im + sumIm;
+        outRe[idx1] = x0Re + c3 * sumRe - s3 * diffIm;
+        outIm[idx1] = x0Im + c3 * sumIm + s3 * diffRe;
+        outRe[idx2] = x0Re + c3 * sumRe + s3 * diffIm;
+        outIm[idx2] = x0Im + c3 * sumIm - s3 * diffRe;
+      }
+    }
+    return twOffset + 2 * (subSize - 1);
+  }
+  radix5(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    const cos1 = Math.cos(2 * Math.PI / 5);
+    const cos2 = Math.cos(4 * Math.PI / 5);
+    const sin1 = -Math.sin(2 * Math.PI / 5);
+    const sin2 = -Math.sin(4 * Math.PI / 5);
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const idx2 = idx0 + 2 * subSize;
+        const idx3 = idx0 + 3 * subSize;
+        const idx4 = idx0 + 4 * subSize;
+        let tw1Re, tw1Im;
+        let tw2Re, tw2Im;
+        let tw3Re, tw3Im;
+        let tw4Re, tw4Im;
+        if (ni === 0) {
+          tw1Re = 1;
+          tw1Im = 0;
+          tw2Re = 1;
+          tw2Im = 0;
+          tw3Re = 1;
+          tw3Im = 0;
+          tw4Re = 1;
+          tw4Im = 0;
+        } else {
+          tw1Re = this.twiddleRe[twOffset + ni - 1] ?? 0;
+          tw1Im = this.twiddleIm[twOffset + ni - 1] ?? 0;
+          tw2Re = this.twiddleRe[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw2Im = this.twiddleIm[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw3Re = this.twiddleRe[twOffset + 2 * (subSize - 1) + ni - 1] ?? 0;
+          tw3Im = this.twiddleIm[twOffset + 2 * (subSize - 1) + ni - 1] ?? 0;
+          tw4Re = this.twiddleRe[twOffset + 3 * (subSize - 1) + ni - 1] ?? 0;
+          tw4Im = this.twiddleIm[twOffset + 3 * (subSize - 1) + ni - 1] ?? 0;
+        }
+        const x0Re = outRe[idx0] ?? 0;
+        const x0Im = outIm[idx0] ?? 0;
+        const x1Re = (outRe[idx1] ?? 0) * tw1Re - (outIm[idx1] ?? 0) * tw1Im;
+        const x1Im = (outRe[idx1] ?? 0) * tw1Im + (outIm[idx1] ?? 0) * tw1Re;
+        const x2Re = (outRe[idx2] ?? 0) * tw2Re - (outIm[idx2] ?? 0) * tw2Im;
+        const x2Im = (outRe[idx2] ?? 0) * tw2Im + (outIm[idx2] ?? 0) * tw2Re;
+        const x3Re = (outRe[idx3] ?? 0) * tw3Re - (outIm[idx3] ?? 0) * tw3Im;
+        const x3Im = (outRe[idx3] ?? 0) * tw3Im + (outIm[idx3] ?? 0) * tw3Re;
+        const x4Re = (outRe[idx4] ?? 0) * tw4Re - (outIm[idx4] ?? 0) * tw4Im;
+        const x4Im = (outRe[idx4] ?? 0) * tw4Im + (outIm[idx4] ?? 0) * tw4Re;
+        const sum14Re = x1Re + x4Re;
+        const sum14Im = x1Im + x4Im;
+        const diff14Re = x1Re - x4Re;
+        const diff14Im = x1Im - x4Im;
+        const sum23Re = x2Re + x3Re;
+        const sum23Im = x2Im + x3Im;
+        const diff23Re = x2Re - x3Re;
+        const diff23Im = x2Im - x3Im;
+        outRe[idx0] = x0Re + sum14Re + sum23Re;
+        outIm[idx0] = x0Im + sum14Im + sum23Im;
+        outRe[idx1] = x0Re + cos1 * sum14Re + cos2 * sum23Re - sin1 * diff14Im - sin2 * diff23Im;
+        outIm[idx1] = x0Im + cos1 * sum14Im + cos2 * sum23Im + sin1 * diff14Re + sin2 * diff23Re;
+        outRe[idx2] = x0Re + cos2 * sum14Re + cos1 * sum23Re - sin2 * diff14Im + sin1 * diff23Im;
+        outIm[idx2] = x0Im + cos2 * sum14Im + cos1 * sum23Im + sin2 * diff14Re - sin1 * diff23Re;
+        outRe[idx3] = x0Re + cos2 * sum14Re + cos1 * sum23Re + sin2 * diff14Im - sin1 * diff23Im;
+        outIm[idx3] = x0Im + cos2 * sum14Im + cos1 * sum23Im - sin2 * diff14Re + sin1 * diff23Re;
+        outRe[idx4] = x0Re + cos1 * sum14Re + cos2 * sum23Re + sin1 * diff14Im + sin2 * diff23Im;
+        outIm[idx4] = x0Im + cos1 * sum14Im + cos2 * sum23Im - sin1 * diff14Re - sin2 * diff23Re;
+      }
+    }
+    return twOffset + 4 * (subSize - 1);
+  }
+};
+function factorize(size) {
+  const factors = [];
+  let remaining = size;
+  for (const prime of [5, 3, 2]) {
+    while (remaining % prime === 0) {
+      factors.push(prime);
+      remaining /= prime;
+    }
+  }
+  if (remaining !== 1) {
+    throw new Error(`MixedRadixFft: size ${size} has unsupported prime factor ${remaining} (only 2, 3, 5 supported)`);
+  }
+  factors.sort((lhs, rhs) => lhs - rhs);
+  return factors;
+}
+function computePermutation(size, radices) {
+  const permutation = new Uint16Array(size);
+  for (let index = 0; index < size; index++) {
+    let remainder = index;
+    let permuted = 0;
+    let base = size;
+    for (const radix of radices) {
+      base = base / radix;
+      const digit = remainder % radix;
+      remainder = Math.floor(remainder / radix);
+      permuted += digit * base;
+    }
+    permutation[index] = permuted;
+  }
+  return permutation;
+}
+function computeTwiddles(radices) {
+  let totalTwiddles = 0;
+  let groupSize = 1;
+  for (const radix of radices) {
+    groupSize *= radix;
+    totalTwiddles += (radix - 1) * (groupSize / radix - 1);
+  }
+  const twiddleRe = new Float32Array(totalTwiddles);
+  const twiddleIm = new Float32Array(totalTwiddles);
+  let twOffset = 0;
+  groupSize = 1;
+  for (const radix of radices) {
+    groupSize *= radix;
+    const subSize = groupSize / radix;
+    for (let kk = 1; kk < radix; kk++) {
+      for (let ni = 1; ni < subSize; ni++) {
+        const angle = -2 * Math.PI * kk * ni / groupSize;
+        twiddleRe[twOffset] = Math.cos(angle);
+        twiddleIm[twOffset] = Math.sin(angle);
+        twOffset++;
+      }
+    }
+  }
+  return { twiddleRe, twiddleIm };
+}
+var STDERR_CAP_BYTES = 64 * 1024;
+var ResampleStream = class {
+  constructor(ffmpegPath, options) {
+    this.chunks = [];
+    this.chunkedBytes = 0;
+    this.stdoutEnded = false;
+    this.exited = false;
+    this.stderr = "";
+    this.closed = false;
+    const { sourceSampleRate, targetSampleRate, channels } = options;
+    if (channels <= 0) throw new Error(`ResampleStream: channels must be > 0, got ${String(channels)}`);
+    if (sourceSampleRate <= 0) throw new Error(`ResampleStream: sourceSampleRate must be > 0, got ${String(sourceSampleRate)}`);
+    if (targetSampleRate <= 0) throw new Error(`ResampleStream: targetSampleRate must be > 0, got ${String(targetSampleRate)}`);
+    this.channels = channels;
+    this.bytesPerFrame = channels * 4;
+    const args = [
+      "-f",
+      "f32le",
+      "-ar",
+      String(sourceSampleRate),
+      "-ac",
+      String(channels),
+      "-i",
+      "pipe:0",
+      "-af",
+      `aresample=${String(targetSampleRate)}:resampler=soxr:dither_method=triangular`,
+      "-f",
+      "f32le",
+      "-ar",
+      String(targetSampleRate),
+      "-ac",
+      String(channels),
+      "pipe:1"
+    ];
+    this.child = spawn(ffmpegPath, args, { stdio: ["pipe", "pipe", "pipe"] });
+    this.child.stdout.on("data", (bytes) => this.onStdoutData(bytes));
+    this.child.stdout.once("end", () => this.onStdoutEnd());
+    this.child.stderr.on("data", (bytes) => this.onStderrData(bytes));
+    this.child.on("error", (error) => this.onExit(error));
+    this.child.once("exit", (code) => {
+      if (code !== null && code !== 0) {
+        const detail = this.stderr ? `: ${this.stderr.slice(0, 1024)}` : "";
+        this.onExit(new Error(`ffmpeg exited ${String(code)}${detail}`));
+        return;
+      }
+      this.onExit();
+    });
+    this.child.stdin.on("error", (error) => {
+      if (error.code === "EPIPE") return;
+      this.exitError ?? (this.exitError = error);
+    });
+  }
+  async write(samples) {
+    if (this.closed) throw new Error("ResampleStream: write after close");
+    if (this.exitError) throw this.exitError;
+    const frames = samples[0]?.length ?? 0;
+    if (frames === 0) return;
+    const interleaved = interleave(samples, frames, this.channels);
+    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    if (this.pendingDrain) await this.pendingDrain;
+    const ok = this.child.stdin.write(buf);
+    if (!ok) {
+      this.pendingDrain = new Promise((resolve) => {
+        this.child.stdin.once("drain", () => {
+          this.pendingDrain = void 0;
+          resolve();
+        });
+      });
+    }
+  }
+  async read(frames) {
+    if (this.closed) throw new Error("ResampleStream: read after close");
+    if (frames <= 0) return this.emptyChannels();
+    if (this.pendingRead) throw new Error("ResampleStream: concurrent read");
+    if (this.chunkedBytes >= this.bytesPerFrame) return this.drainOutput(frames);
+    if (this.exitError) throw this.exitError;
+    if (this.stdoutEnded && this.exited) return this.emptyChannels();
+    return new Promise((resolve, reject) => {
+      this.pendingRead = { resolve, reject, frames };
+      this.maybeSatisfyPendingRead();
+    });
+  }
+  async end() {
+    if (this.closed) return;
+    if (this.pendingDrain) await this.pendingDrain;
+    if (!this.child.stdin.writableEnded) this.child.stdin.end();
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.pendingRead) {
+      this.pendingRead.reject(new Error("ResampleStream: close while read pending"));
+      this.pendingRead = void 0;
+    }
+    try {
+      if (!this.child.stdin.writableEnded) {
+        try {
+          this.child.stdin.end();
+        } catch {
+        }
+      }
+    } finally {
+      if (!this.exited && this.child.exitCode === null && !this.child.killed) {
+        this.child.kill("SIGTERM");
+      }
+    }
+    if (!this.exited) {
+      await new Promise((resolve) => {
+        let settled = false;
+        const settle = () => {
+          if (!settled) {
+            settled = true;
+            resolve();
+          }
+        };
+        const timeout = setTimeout(() => {
+          this.child.kill("SIGKILL");
+          settle();
+        }, 5e3);
+        this.child.once("exit", () => {
+          clearTimeout(timeout);
+          settle();
+        });
+      });
+    }
+  }
+  onStdoutData(bytes) {
+    if (bytes.length > 0) {
+      this.chunks.push(bytes);
+      this.chunkedBytes += bytes.length;
+    }
+    this.maybeSatisfyPendingRead();
+  }
+  onStdoutEnd() {
+    this.stdoutEnded = true;
+    this.maybeSatisfyPendingRead();
+  }
+  onStderrData(bytes) {
+    if (this.stderr.length >= STDERR_CAP_BYTES) return;
+    const remaining = STDERR_CAP_BYTES - this.stderr.length;
+    const text = bytes.toString("utf8");
+    this.stderr += text.length > remaining ? text.slice(0, remaining) : text;
+  }
+  onExit(error) {
+    this.exited = true;
+    if (error) this.exitError ?? (this.exitError = error);
+    this.maybeSatisfyPendingRead();
+  }
+  maybeSatisfyPendingRead() {
+    if (!this.pendingRead) return;
+    const { frames, resolve, reject } = this.pendingRead;
+    if (this.chunkedBytes >= this.bytesPerFrame) {
+      this.pendingRead = void 0;
+      resolve(this.drainOutput(frames));
+      return;
+    }
+    if (this.stdoutEnded && this.exited) {
+      this.pendingRead = void 0;
+      if (this.exitError) {
+        reject(this.exitError);
+        return;
+      }
+      resolve(this.emptyChannels());
+    }
+  }
+  drainOutput(frames) {
+    const wantBytes = frames * this.bytesPerFrame;
+    const available = Math.min(this.chunkedBytes, wantBytes);
+    const completeFrames = Math.floor(available / this.bytesPerFrame);
+    if (completeFrames === 0) return this.emptyChannels();
+    const completeBytes = completeFrames * this.bytesPerFrame;
+    const aligned = Buffer.allocUnsafe(completeBytes);
+    let written = 0;
+    while (written < completeBytes) {
+      const head = this.chunks[0];
+      if (!head) break;
+      const remaining = completeBytes - written;
+      if (head.length <= remaining) {
+        head.copy(aligned, written, 0, head.length);
+        written += head.length;
+        this.chunks.shift();
+        continue;
+      }
+      head.copy(aligned, written, 0, remaining);
+      this.chunks[0] = head.subarray(remaining);
+      written += remaining;
+    }
+    this.chunkedBytes -= completeBytes;
+    return deinterleaveBuffer(aligned, this.channels);
+  }
+  emptyChannels() {
+    const out = [];
+    for (let ch = 0; ch < this.channels; ch++) out.push(new Float32Array(0));
+    return out;
+  }
+};
+var SlidingWindowMaxStream = class {
+  constructor(halfWidth) {
+    this.dequeHead = 0;
+    this.dequeTail = 0;
+    this.consumedFrames = 0;
+    this.emittedFrames = 0;
+    if (halfWidth < 0 || !Number.isFinite(halfWidth)) {
+      throw new RangeError(`SlidingWindowMaxStream: halfWidth must be a non-negative finite number, got ${halfWidth}`);
+    }
+    this.halfWidth = halfWidth;
+    const ringCapacity = 2 * halfWidth + 1;
+    this.lookAhead = new Float32Array(ringCapacity);
+    this.deque = new Int32Array(ringCapacity);
+  }
+  push(chunk, isFinal) {
+    const chunkLength = chunk.length;
+    const halfWidth = this.halfWidth;
+    const ringSize = this.lookAhead.length;
+    const dequeCapacity = this.deque.length;
+    const totalAfter = this.consumedFrames + chunkLength;
+    const targetEmittedAfter = isFinal ? totalAfter : Math.max(0, totalAfter - halfWidth);
+    const emitCount = Math.max(0, targetEmittedAfter - this.emittedFrames);
+    const output = new Float32Array(emitCount);
+    let outputCursor = 0;
+    for (let chunkIdx = 0; chunkIdx < chunkLength; chunkIdx++) {
+      const inputIdx = this.consumedFrames;
+      const value = chunk[chunkIdx] ?? 0;
+      this.lookAhead[inputIdx % ringSize] = value;
+      while (this.dequeTail > this.dequeHead) {
+        const tailIdx = this.deque[(this.dequeTail - 1) % dequeCapacity] ?? 0;
+        const tailValue = this.lookAhead[tailIdx % ringSize] ?? 0;
+        if (tailValue > value) break;
+        this.dequeTail--;
+      }
+      this.deque[this.dequeTail % dequeCapacity] = inputIdx;
+      this.dequeTail++;
+      this.consumedFrames++;
+      const outputIdx = inputIdx - halfWidth;
+      if (outputIdx < 0) continue;
+      const leftEdge = Math.max(0, outputIdx - halfWidth);
+      while (this.dequeTail > this.dequeHead && (this.deque[this.dequeHead % dequeCapacity] ?? 0) < leftEdge) {
+        this.dequeHead++;
+      }
+      const frontIdx = this.deque[this.dequeHead % dequeCapacity] ?? 0;
+      output[outputCursor] = this.lookAhead[frontIdx % ringSize] ?? 0;
+      outputCursor++;
+      this.emittedFrames++;
+    }
+    if (isFinal) {
+      const finalLength = this.consumedFrames;
+      while (this.emittedFrames < finalLength) {
+        const outputIdx = this.emittedFrames;
+        const leftEdge = Math.max(0, outputIdx - halfWidth);
+        while (this.dequeTail > this.dequeHead && (this.deque[this.dequeHead % dequeCapacity] ?? 0) < leftEdge) {
+          this.dequeHead++;
+        }
+        if (this.dequeTail === this.dequeHead) {
+          output[outputCursor] = 0;
+        } else {
+          const frontIdx = this.deque[this.dequeHead % dequeCapacity] ?? 0;
+          output[outputCursor] = this.lookAhead[frontIdx % ringSize] ?? 0;
+        }
+        outputCursor++;
+        this.emittedFrames++;
+      }
+    }
+    return output;
+  }
+};
+var SlidingWindowMinStream = class {
+  constructor(halfWidth) {
+    this.dequeHead = 0;
+    this.dequeTail = 0;
+    this.consumedFrames = 0;
+    this.emittedFrames = 0;
+    if (halfWidth < 0 || !Number.isFinite(halfWidth)) {
+      throw new RangeError(`SlidingWindowMinStream: halfWidth must be a non-negative finite number, got ${halfWidth}`);
+    }
+    this.halfWidth = halfWidth;
+    const ringCapacity = 2 * halfWidth + 1;
+    this.lookAhead = new Float32Array(ringCapacity);
+    this.deque = new Int32Array(ringCapacity);
+  }
+  push(chunk, isFinal) {
+    const chunkLength = chunk.length;
+    const halfWidth = this.halfWidth;
+    const ringSize = this.lookAhead.length;
+    const dequeCapacity = this.deque.length;
+    const totalAfter = this.consumedFrames + chunkLength;
+    const targetEmittedAfter = isFinal ? totalAfter : Math.max(0, totalAfter - halfWidth);
+    const emitCount = Math.max(0, targetEmittedAfter - this.emittedFrames);
+    const output = new Float32Array(emitCount);
+    let outputCursor = 0;
+    for (let chunkIdx = 0; chunkIdx < chunkLength; chunkIdx++) {
+      const inputIdx = this.consumedFrames;
+      const value = chunk[chunkIdx] ?? 0;
+      this.lookAhead[inputIdx % ringSize] = value;
+      while (this.dequeTail > this.dequeHead) {
+        const tailIdx = this.deque[(this.dequeTail - 1) % dequeCapacity] ?? 0;
+        const tailValue = this.lookAhead[tailIdx % ringSize] ?? 0;
+        if (tailValue < value) break;
+        this.dequeTail--;
+      }
+      this.deque[this.dequeTail % dequeCapacity] = inputIdx;
+      this.dequeTail++;
+      this.consumedFrames++;
+      const outputIdx = inputIdx - halfWidth;
+      if (outputIdx < 0) continue;
+      const leftEdge = Math.max(0, outputIdx - halfWidth);
+      while (this.dequeTail > this.dequeHead && (this.deque[this.dequeHead % dequeCapacity] ?? 0) < leftEdge) {
+        this.dequeHead++;
+      }
+      const frontIdx = this.deque[this.dequeHead % dequeCapacity] ?? 0;
+      output[outputCursor] = this.lookAhead[frontIdx % ringSize] ?? 0;
+      outputCursor++;
+      this.emittedFrames++;
+    }
+    if (isFinal) {
+      const finalLength = this.consumedFrames;
+      while (this.emittedFrames < finalLength) {
+        const outputIdx = this.emittedFrames;
+        const leftEdge = Math.max(0, outputIdx - halfWidth);
+        while (this.dequeTail > this.dequeHead && (this.deque[this.dequeHead % dequeCapacity] ?? 0) < leftEdge) {
+          this.dequeHead++;
+        }
+        if (this.dequeTail === this.dequeHead) {
+          output[outputCursor] = 0;
+        } else {
+          const frontIdx = this.deque[this.dequeHead % dequeCapacity] ?? 0;
+          output[outputCursor] = this.lookAhead[frontIdx % ringSize] ?? 0;
+        }
+        outputCursor++;
+        this.emittedFrames++;
+      }
+    }
+    return output;
+  }
+};
+var batchInputCache = /* @__PURE__ */ new Map();
+function getBatchInput(fftSize, numFrames) {
+  const needed = fftSize * numFrames;
+  const cached = batchInputCache.get(fftSize);
+  if (cached && cached.length >= needed) return cached;
+  const grown = new Float32Array(needed);
+  batchInputCache.set(fftSize, grown);
+  return grown;
+}
+var batchTimeCache = /* @__PURE__ */ new Map();
+function getBatchTime(fftSize, numFrames) {
+  const needed = fftSize * numFrames;
+  const cached = batchTimeCache.get(fftSize);
+  if (cached && cached.length >= needed) return cached;
+  const grown = new Float32Array(needed);
+  batchTimeCache.set(fftSize, grown);
+  return grown;
+}
+function stft(signal, fftSize, hopSize, output, backend, fftAddonOptions) {
+  const window = hanningWindow(fftSize);
+  const numFrames = Math.floor((signal.length - fftSize) / hopSize) + 1;
+  const halfSize = fftSize / 2 + 1;
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  const real = output?.real ?? (numFrames > 0 ? new Float32Array(halfSize * numFrames) : new Float32Array(0));
+  const imag = output?.imag ?? (numFrames > 0 ? new Float32Array(halfSize * numFrames) : new Float32Array(0));
+  if (numFrames <= 0) {
+    return { real, imag, frames: 0, fftSize };
+  }
+  if (addon) {
+    const batchInput = getBatchInput(fftSize, numFrames);
+    for (let frame = 0; frame < numFrames; frame++) {
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        batchInput[frame * fftSize + index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
+      }
+    }
+    if (typeof addon.batchFftInto === "function") {
+      addon.batchFftInto(batchInput.subarray(0, fftSize * numFrames), real.subarray(0, halfSize * numFrames), imag.subarray(0, halfSize * numFrames), fftSize, numFrames);
+    } else {
+      const { re: batchRe, im: batchIm } = addon.batchFft(batchInput.subarray(0, fftSize * numFrames), fftSize, numFrames);
+      real.set(batchRe.subarray(0, halfSize * numFrames));
+      imag.set(batchIm.subarray(0, halfSize * numFrames));
+    }
+    return { real, imag, frames: numFrames, fftSize };
+  }
+  const windowed = new Float32Array(fftSize);
+  const workspace = createFftWorkspace(fftSize);
+  for (let frame = 0; frame < numFrames; frame++) {
+    const offset = frame * hopSize;
+    for (let index = 0; index < fftSize; index++) {
+      windowed[index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
+    }
+    const { re, im } = fft(windowed, workspace);
+    const dstOffset = frame * halfSize;
+    for (let bin = 0; bin < halfSize; bin++) {
+      real[dstOffset + bin] = re[bin] ?? 0;
+      imag[dstOffset + bin] = im[bin] ?? 0;
+    }
+  }
+  return { real, imag, frames: numFrames, fftSize };
+}
+function istft(result, hopSize, outputLength, backend, fftAddonOptions) {
+  const { real, imag, frames, fftSize } = result;
+  const window = hanningWindow(fftSize);
+  const output = new Float32Array(outputLength);
+  const windowSum = new Float32Array(outputLength);
+  const halfSize = fftSize / 2 + 1;
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  if (addon && frames > 0) {
+    const reView = real.subarray(0, halfSize * frames);
+    const imView = imag.subarray(0, halfSize * frames);
+    let timeDomainBatch;
+    if (typeof addon.batchIfftInto === "function") {
+      const batchTime = getBatchTime(fftSize, frames);
+      addon.batchIfftInto(reView, imView, batchTime.subarray(0, fftSize * frames), fftSize, frames);
+      timeDomainBatch = batchTime;
+    } else {
+      timeDomainBatch = addon.batchIfft(reView, imView, fftSize, frames);
+    }
+    for (let frame = 0; frame < frames; frame++) {
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        const pos = offset + index;
+        if (pos < outputLength) {
+          output[pos] = (output[pos] ?? 0) + (timeDomainBatch[frame * fftSize + index] ?? 0) * (window[index] ?? 0);
+          windowSum[pos] = (windowSum[pos] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+        }
+      }
+    }
+  } else {
+    const fullRe = new Float32Array(fftSize);
+    const fullIm = new Float32Array(fftSize);
+    const workspace = createFftWorkspace(fftSize);
+    for (let frame = 0; frame < frames; frame++) {
+      const srcOffset = frame * halfSize;
+      fullRe.fill(0);
+      fullIm.fill(0);
+      for (let bin = 0; bin < halfSize; bin++) {
+        fullRe[bin] = real[srcOffset + bin] ?? 0;
+        fullIm[bin] = imag[srcOffset + bin] ?? 0;
+      }
+      for (let index = 1; index < halfSize - 1; index++) {
+        fullRe[fftSize - index] = real[srcOffset + index] ?? 0;
+        fullIm[fftSize - index] = -(imag[srcOffset + index] ?? 0);
+      }
+      const timeDomain = ifft(fullRe, fullIm, workspace);
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        const pos = offset + index;
+        if (pos < outputLength) {
+          output[pos] = (output[pos] ?? 0) + (timeDomain[index] ?? 0) * (window[index] ?? 0);
+          windowSum[pos] = (windowSum[pos] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+        }
+      }
+    }
+  }
+  for (let index = 0; index < outputLength; index++) {
+    const ws = windowSum[index] ?? 0;
+    if (ws > 1e-8) {
+      output[index] = (output[index] ?? 0) / ws;
+    }
+  }
+  return output;
+}
+var hanningWindowCache = /* @__PURE__ */ new Map();
+function hanningWindow(size, periodic = true) {
+  const key = `${size}:${periodic ? "p" : "s"}`;
+  const cached = hanningWindowCache.get(key);
+  if (cached) return cached;
+  const window = new Float32Array(size);
+  const denominator = periodic ? size : size - 1;
+  for (let index = 0; index < size; index++) {
+    window[index] = 0.5 * (1 - Math.cos(2 * Math.PI * index / denominator));
+  }
+  hanningWindowCache.set(key, window);
+  return window;
+}
+function createFftWorkspace(size) {
+  return {
+    re: new Float32Array(size),
+    im: new Float32Array(size),
+    outRe: new Float32Array(size),
+    outIm: new Float32Array(size)
+  };
+}
+function fft(input, workspace) {
+  const size = input.length;
+  const re = workspace ? workspace.re : new Float32Array(size);
+  const im = workspace ? workspace.im : new Float32Array(size);
+  re.set(input);
+  if (workspace) im.fill(0);
+  if (size <= 1) return { re, im };
+  bitReverse(re, im, size);
+  butterflyStages(re, im, size);
+  return { re, im };
+}
+function ifft(re, im, workspace) {
+  const size = re.length;
+  const outRe = workspace ? workspace.outRe : Float32Array.from(re);
+  const outIm = workspace ? workspace.outIm : new Float32Array(size);
+  if (workspace) outRe.set(re);
+  for (let index = 0; index < size; index++) {
+    outIm[index] = -(im[index] ?? 0);
+  }
+  bitReverse(outRe, outIm, size);
+  butterflyStages(outRe, outIm, size);
+  for (let index = 0; index < size; index++) {
+    outRe[index] = (outRe[index] ?? 0) / size;
+  }
+  return outRe;
+}
+function bitReverse(re, im, size) {
+  let rev = 0;
+  for (let index = 0; index < size - 1; index++) {
+    if (index < rev) {
+      const tempRe = re[index];
+      const tempIm = im[index];
+      re[index] = re[rev];
+      im[index] = im[rev];
+      re[rev] = tempRe;
+      im[rev] = tempIm;
+    }
+    let bit = size >> 1;
+    while (bit <= rev) {
+      rev -= bit;
+      bit >>= 1;
+    }
+    rev += bit;
+  }
+}
+var twiddleCache = /* @__PURE__ */ new Map();
+function getTwiddleFactors(size) {
+  let cached = twiddleCache.get(size);
+  if (cached) return cached;
+  const totalFactors = size / 2 * Math.log2(size);
+  const twRe = new Float32Array(totalFactors);
+  const twIm = new Float32Array(totalFactors);
+  let offset = 0;
+  for (let step = 2; step <= size; step *= 2) {
+    const halfStep = step / 2;
+    const angle = -2 * Math.PI / step;
+    for (let pair = 0; pair < halfStep; pair++) {
+      twRe[offset + pair] = Math.cos(angle * pair);
+      twIm[offset + pair] = Math.sin(angle * pair);
+    }
+    offset += halfStep;
+  }
+  cached = { re: twRe, im: twIm };
+  twiddleCache.set(size, cached);
+  return cached;
+}
+function butterflyStages(re, im, size) {
+  const twiddle = getTwiddleFactors(size);
+  const twRe = twiddle.re;
+  const twIm = twiddle.im;
+  let twOffset = 0;
+  for (let step = 2; step <= size; step *= 2) {
+    const halfStep = step / 2;
+    for (let group = 0; group < size; group += step) {
+      for (let pair = 0; pair < halfStep; pair++) {
+        const wr = twRe[twOffset + pair];
+        const wi = twIm[twOffset + pair];
+        const evenIdx = group + pair;
+        const oddIdx = group + pair + halfStep;
+        const oddRe = re[oddIdx];
+        const oddIm = im[oddIdx];
+        const evenRe = re[evenIdx];
+        const evenIm = im[evenIdx];
+        const tRe = oddRe * wr - oddIm * wi;
+        const tIm = oddRe * wi + oddIm * wr;
+        re[oddIdx] = evenRe - tRe;
+        im[oddIdx] = evenIm - tIm;
+        re[evenIdx] = evenRe + tRe;
+        im[evenIdx] = evenIm + tIm;
+      }
+    }
+    twOffset += halfStep;
+  }
+}
+var TAPS_PER_PHASE_4X = 12;
+var HISTORY_LENGTH_4X = TAPS_PER_PHASE_4X;
+var P1T0 = 0.001708984375;
+var P1T1 = 0.010986328125;
+var P1T2 = -0.0196533203125;
+var P1T3 = 0.033203125;
+var P1T4 = -0.0594482421875;
+var P1T5 = 0.1373291015625;
+var P1T6 = 0.97216796875;
+var P1T7 = -0.102294921875;
+var P1T8 = 0.047607421875;
+var P1T9 = -0.026611328125;
+var P1T10 = 0.014892578125;
+var P1T11 = -0.00830078125;
+var P2T0 = -0.0291748046875;
+var P2T1 = 0.029296875;
+var P2T2 = -0.0517578125;
+var P2T3 = 0.089111328125;
+var P2T4 = -0.16650390625;
+var P2T5 = 0.465087890625;
+var P2T6 = 0.77978515625;
+var P2T7 = -0.2003173828125;
+var P2T8 = 0.1015625;
+var P2T9 = -0.0582275390625;
+var P2T10 = 0.0330810546875;
+var P2T11 = -0.0189208984375;
+var P3T0 = -0.0189208984375;
+var P3T1 = 0.0330810546875;
+var P3T2 = -0.0582275390625;
+var P3T3 = 0.1015625;
+var P3T4 = -0.2003173828125;
+var P3T5 = 0.77978515625;
+var P3T6 = 0.465087890625;
+var P3T7 = -0.16650390625;
+var P3T8 = 0.089111328125;
+var P3T9 = -0.0517578125;
+var P3T10 = 0.029296875;
+var P3T11 = -0.0291748046875;
+var TruePeakUpsampler = class {
+  constructor(factor = 4) {
+    this.work = new Float64Array(0);
+    if (factor !== 4) {
+      throw new Error(`TruePeakUpsampler: factor ${factor} is not yet implemented; only 4\xD7 (BS.1770-4 Annex 1) is supported`);
+    }
+    this.factor = factor;
+    this.history = new Float64Array(HISTORY_LENGTH_4X);
+  }
+  // `outputScratch` (>= input.length × factor) avoids the per-call allocation; the returned view aliases it.
+  upsample(input, outputScratch) {
+    const factor = this.factor;
+    const inputLength = input.length;
+    const outputLength = inputLength * factor;
+    const output = outputScratch !== void 0 && outputScratch.length >= outputLength ? outputScratch.subarray(0, outputLength) : new Float32Array(outputLength);
+    const history = this.history;
+    const historyLength = HISTORY_LENGTH_4X;
+    const workLength = historyLength + inputLength;
+    if (this.work.length < workLength) {
+      this.work = new Float64Array(workLength);
+    }
+    const work = this.work;
+    work.set(history, 0);
+    for (let inIdx = 0; inIdx < inputLength; inIdx++) {
+      work[historyLength + inIdx] = input[inIdx] ?? 0;
+    }
+    for (let inIdx = 0; inIdx < inputLength; inIdx++) {
+      const currentIdx = historyLength + inIdx;
+      const outOffset = inIdx * factor;
+      output[outOffset] = input[inIdx] ?? 0;
+      const v0 = work[currentIdx] ?? 0;
+      const v1 = work[currentIdx - 1] ?? 0;
+      const v2 = work[currentIdx - 2] ?? 0;
+      const v3 = work[currentIdx - 3] ?? 0;
+      const v4 = work[currentIdx - 4] ?? 0;
+      const v5 = work[currentIdx - 5] ?? 0;
+      const v6 = work[currentIdx - 6] ?? 0;
+      const v7 = work[currentIdx - 7] ?? 0;
+      const v8 = work[currentIdx - 8] ?? 0;
+      const v9 = work[currentIdx - 9] ?? 0;
+      const v10 = work[currentIdx - 10] ?? 0;
+      const v11 = work[currentIdx - 11] ?? 0;
+      let acc1 = 0;
+      acc1 += P1T0 * v0;
+      acc1 += P1T1 * v1;
+      acc1 += P1T2 * v2;
+      acc1 += P1T3 * v3;
+      acc1 += P1T4 * v4;
+      acc1 += P1T5 * v5;
+      acc1 += P1T6 * v6;
+      acc1 += P1T7 * v7;
+      acc1 += P1T8 * v8;
+      acc1 += P1T9 * v9;
+      acc1 += P1T10 * v10;
+      acc1 += P1T11 * v11;
+      let acc2 = 0;
+      acc2 += P2T0 * v0;
+      acc2 += P2T1 * v1;
+      acc2 += P2T2 * v2;
+      acc2 += P2T3 * v3;
+      acc2 += P2T4 * v4;
+      acc2 += P2T5 * v5;
+      acc2 += P2T6 * v6;
+      acc2 += P2T7 * v7;
+      acc2 += P2T8 * v8;
+      acc2 += P2T9 * v9;
+      acc2 += P2T10 * v10;
+      acc2 += P2T11 * v11;
+      let acc3 = 0;
+      acc3 += P3T0 * v0;
+      acc3 += P3T1 * v1;
+      acc3 += P3T2 * v2;
+      acc3 += P3T3 * v3;
+      acc3 += P3T4 * v4;
+      acc3 += P3T5 * v5;
+      acc3 += P3T6 * v6;
+      acc3 += P3T7 * v7;
+      acc3 += P3T8 * v8;
+      acc3 += P3T9 * v9;
+      acc3 += P3T10 * v10;
+      acc3 += P3T11 * v11;
+      output[outOffset + 1] = acc1;
+      output[outOffset + 2] = acc2;
+      output[outOffset + 3] = acc3;
+    }
+    if (inputLength >= historyLength) {
+      history.set(work.subarray(workLength - historyLength, workLength), 0);
+    } else if (inputLength > 0) {
+      history.copyWithin(0, inputLength);
+      history.set(work.subarray(historyLength, workLength), historyLength - inputLength);
+    }
+    return output;
+  }
+  reset() {
+    this.history.fill(0);
+    this.work = new Float64Array(0);
+  }
+};
+var DEFAULT_OVERSAMPLE_FACTOR = 4;
+var TruePeakAccumulator = class {
+  constructor(_sampleRate, channelCount, oversampleFactor = DEFAULT_OVERSAMPLE_FACTOR) {
+    this.upsampleScratch = new Float32Array(0);
+    this.runningMax = 0;
+    if (channelCount <= 0) {
+      throw new Error(`TruePeakAccumulator: channelCount must be positive, got ${channelCount}`);
+    }
+    this.channelCount = channelCount;
+    const upsamplers = [];
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      upsamplers.push(new TruePeakUpsampler(oversampleFactor));
+    }
+    this.upsamplers = upsamplers;
+  }
+  // `channels[c]` needs >= `frames` valid samples from index 0 (oversized OK); advances per-channel upsampler state as if appended contiguously.
+  push(channels, frames) {
+    if (channels.length !== this.channelCount) {
+      throw new Error(`TruePeakAccumulator: push got ${channels.length} channels, expected ${this.channelCount}`);
+    }
+    if (frames <= 0) return;
+    for (let channelIndex = 0; channelIndex < this.channelCount; channelIndex++) {
+      const channel = channels[channelIndex];
+      if (channel === void 0 || channel.length < frames) {
+        throw new Error(`TruePeakAccumulator: channel ${channelIndex} has ${channel?.length ?? 0} samples, fewer than the requested ${frames}`);
+      }
+      const upsampler = this.upsamplers[channelIndex];
+      if (upsampler === void 0) {
+        throw new Error(`TruePeakAccumulator: missing upsampler for channel ${channelIndex}`);
+      }
+      const slice = channel.length === frames ? channel : channel.subarray(0, frames);
+      if (this.upsampleScratch.length < frames * upsampler.factor) {
+        this.upsampleScratch = new Float32Array(frames * upsampler.factor);
+      }
+      const upsampled = upsampler.upsample(slice, this.upsampleScratch);
+      for (let index = 0; index < upsampled.length; index++) {
+        const sample = upsampled[index] ?? 0;
+        const magnitude = sample < 0 ? -sample : sample;
+        if (magnitude > this.runningMax) this.runningMax = magnitude;
+      }
+    }
+  }
+  finalize() {
+    return this.runningMax;
+  }
+};
+function complexFft(inRe, inIm, outRe, outIm, workspaceA, workspaceB) {
+  const { re: reOfRe, im: imOfRe } = fft(inRe, workspaceA);
+  const { re: reOfIm, im: imOfIm } = fft(inIm, workspaceB);
+  const size = inRe.length;
+  for (let ii = 0; ii < size; ii++) {
+    outRe[ii] = reOfRe[ii] - imOfIm[ii];
+    outIm[ii] = imOfRe[ii] + reOfIm[ii];
+  }
+}
+function applyDfttSmoothing(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output, fftBackend, fftAddonOptions, profileMs) {
+  const addon = fftBackend ? getFftAddon(fftBackend, fftAddonOptions) : null;
+  if (!addon || typeof addon.batchFft2D !== "function") {
+    applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output);
+    return;
+  }
+  let profileMark = profileMs ? performance.now() : 0;
+  const profileAdd = (key) => {
+    if (!profileMs) return;
+    const now = performance.now();
+    profileMs[key] += now - profileMark;
+    profileMark = now;
+  };
+  const { blockFreq, blockTime, hopFreq, hopTime, threshold } = dfttOptions;
+  const winFreq = hanningWindow(blockFreq, false);
+  const winTime = hanningWindow(blockTime, false);
+  const win2d = new Float32Array(blockTime * blockFreq);
+  for (let tf = 0; tf < blockTime; tf++) {
+    for (let bf = 0; bf < blockFreq; bf++) {
+      win2d[tf * blockFreq + bf] = winTime[tf] * winFreq[bf];
+    }
+  }
+  const blocksPerFrame = Math.ceil(numFrames / hopTime);
+  const blocksPerBin = Math.ceil(numBins / hopFreq);
+  const totalBlocks = blocksPerFrame * blocksPerBin;
+  const blockSize = blockTime * blockFreq;
+  const complexBinsPerRow = blockFreq / 2 + 1;
+  const complexBlockSize = blockTime * complexBinsPerRow;
+  const rawBatch = new Float32Array(totalBlocks * blockSize);
+  const nlmBatch = new Float32Array(totalBlocks * blockSize);
+  for (let frameIdx = 0; frameIdx < blocksPerFrame; frameIdx++) {
+    const frameStart = frameIdx * hopTime;
+    for (let binIdx = 0; binIdx < blocksPerBin; binIdx++) {
+      const binStart = binIdx * hopFreq;
+      const blockIdx = frameIdx * blocksPerBin + binIdx;
+      const blockOffset = blockIdx * blockSize;
+      for (let tf = 0; tf < blockTime; tf++) {
+        const srcFrame = frameStart + tf < numFrames ? frameStart + tf : numFrames - 1;
+        for (let bf = 0; bf < blockFreq; bf++) {
+          const srcBin = binStart + bf < numBins ? binStart + bf : numBins - 1;
+          const winVal = win2d[tf * blockFreq + bf];
+          const srcPos = srcFrame * numBins + srcBin;
+          const dstPos = blockOffset + tf * blockFreq + bf;
+          rawBatch[dstPos] = rawMask[srcPos] * winVal;
+          nlmBatch[dstPos] = nlmSmoothed[srcPos] * winVal;
+        }
+      }
+    }
+  }
+  profileAdd("fill");
+  const rawFft = addon.batchFft2D(rawBatch, blockTime, blockFreq, totalBlocks);
+  const nlmFft = addon.batchFft2D(nlmBatch, blockTime, blockFreq, totalBlocks);
+  profileAdd("forward");
+  const sigmaSq = threshold * threshold;
+  const totalComplex = totalBlocks * complexBlockSize;
+  const rawRe = rawFft.re;
+  const rawIm = rawFft.im;
+  const nlmRe = nlmFft.re;
+  const nlmIm = nlmFft.im;
+  for (let flatIdx = 0; flatIdx < totalComplex; flatIdx++) {
+    const nRe = nlmRe[flatIdx];
+    const nIm = nlmIm[flatIdx];
+    const nMagSq = nRe * nRe + nIm * nIm;
+    const gain = nMagSq / (nMagSq + sigmaSq);
+    rawRe[flatIdx] = rawRe[flatIdx] * gain;
+    rawIm[flatIdx] = rawIm[flatIdx] * gain;
+  }
+  profileAdd("gain");
+  const synth = addon.batchIfft2D(rawRe, rawIm, blockTime, blockFreq, totalBlocks);
+  profileAdd("inverse");
+  const accumulator = new Float32Array(numFrames * numBins);
+  const windowSumSq = new Float32Array(numFrames * numBins);
+  for (let frameIdx = 0; frameIdx < blocksPerFrame; frameIdx++) {
+    const frameStart = frameIdx * hopTime;
+    for (let binIdx = 0; binIdx < blocksPerBin; binIdx++) {
+      const binStart = binIdx * hopFreq;
+      const blockIdx = frameIdx * blocksPerBin + binIdx;
+      const blockOffset = blockIdx * blockSize;
+      for (let tf = 0; tf < blockTime; tf++) {
+        const destFrame = frameStart + tf;
+        if (destFrame >= numFrames) break;
+        for (let bf = 0; bf < blockFreq; bf++) {
+          const destBin = binStart + bf;
+          if (destBin >= numBins) break;
+          const winVal = win2d[tf * blockFreq + bf];
+          const destPos = destFrame * numBins + destBin;
+          const srcVal = synth[blockOffset + tf * blockFreq + bf];
+          accumulator[destPos] = accumulator[destPos] + srcVal * winVal;
+          windowSumSq[destPos] = windowSumSq[destPos] + winVal * winVal;
+        }
+      }
+    }
+  }
+  profileAdd("ola");
+  for (let flatIdx = 0; flatIdx < numFrames * numBins; flatIdx++) {
+    const ws = windowSumSq[flatIdx];
+    if (ws > 1e-8) {
+      const normalisedVal = accumulator[flatIdx] / ws;
+      output[flatIdx] = normalisedVal < 0 ? 0 : normalisedVal > 1 ? 1 : normalisedVal;
+    } else {
+      output[flatIdx] = rawMask[flatIdx];
+    }
+  }
+  profileAdd("normalize");
+}
+function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output) {
+  const { blockFreq, blockTime, hopFreq, hopTime, threshold } = dfttOptions;
+  const winFreq = hanningWindow(blockFreq, false);
+  const winTime = hanningWindow(blockTime, false);
+  const win2d = new Float32Array(blockTime * blockFreq);
+  for (let tf = 0; tf < blockTime; tf++) {
+    for (let bf = 0; bf < blockFreq; bf++) {
+      win2d[tf * blockFreq + bf] = winTime[tf] * winFreq[bf];
+    }
+  }
+  const accumulator = new Float32Array(numFrames * numBins);
+  const windowSumSq = new Float32Array(numFrames * numBins);
+  const blockRaw = new Float32Array(blockTime * blockFreq);
+  const blockNlm = new Float32Array(blockTime * blockFreq);
+  const rawRowRe = new Float32Array(blockTime * blockFreq);
+  const rawRowIm = new Float32Array(blockTime * blockFreq);
+  const nlmRowRe = new Float32Array(blockTime * blockFreq);
+  const nlmRowIm = new Float32Array(blockTime * blockFreq);
+  const colInRe = new Float32Array(blockTime * blockFreq);
+  const colInIm = new Float32Array(blockTime * blockFreq);
+  const rawColRe = new Float32Array(blockTime * blockFreq);
+  const rawColIm = new Float32Array(blockTime * blockFreq);
+  const nlmColRe = new Float32Array(blockTime * blockFreq);
+  const nlmColIm = new Float32Array(blockTime * blockFreq);
+  const gainColRe = new Float32Array(blockTime * blockFreq);
+  const gainColIm = new Float32Array(blockTime * blockFreq);
+  const scratchRe = new Float32Array(blockTime);
+  const scratchIm = new Float32Array(blockTime);
+  const scratchOutRe = new Float32Array(blockTime);
+  const scratchOutIm = new Float32Array(blockTime);
+  const rowScratch = new Float32Array(blockFreq);
+  const rowScratchRe = new Float32Array(blockFreq);
+  const rowScratchIm = new Float32Array(blockFreq);
+  const synthBlock = new Float32Array(blockTime * blockFreq);
+  const rowFwdWorkspace = createFftWorkspace(blockFreq);
+  const colFwdWorkspaceA = createFftWorkspace(blockTime);
+  const colFwdWorkspaceB = createFftWorkspace(blockTime);
+  const colInvWorkspace = createFftWorkspace(blockTime);
+  const rowInvWorkspace = createFftWorkspace(blockFreq);
+  for (let frameStart = 0; frameStart < numFrames; frameStart += hopTime) {
+    for (let binStart = 0; binStart < numBins; binStart += hopFreq) {
+      for (let tf = 0; tf < blockTime; tf++) {
+        const srcFrame = frameStart + tf < numFrames ? frameStart + tf : numFrames - 1;
+        for (let bf = 0; bf < blockFreq; bf++) {
+          const srcBin = binStart + bf < numBins ? binStart + bf : numBins - 1;
+          const winVal = win2d[tf * blockFreq + bf];
+          const srcPos = srcFrame * numBins + srcBin;
+          blockRaw[tf * blockFreq + bf] = rawMask[srcPos] * winVal;
+          blockNlm[tf * blockFreq + bf] = nlmSmoothed[srcPos] * winVal;
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        for (let bf = 0; bf < blockFreq; bf++) {
+          rowScratch[bf] = blockRaw[tf * blockFreq + bf];
+        }
+        const { re: rowRe, im: rowIm } = fft(rowScratch, rowFwdWorkspace);
+        for (let bf = 0; bf < blockFreq; bf++) {
+          rawRowRe[tf * blockFreq + bf] = rowRe[bf];
+          rawRowIm[tf * blockFreq + bf] = rowIm[bf];
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        for (let bf = 0; bf < blockFreq; bf++) {
+          rowScratch[bf] = blockNlm[tf * blockFreq + bf];
+        }
+        const { re: rowRe, im: rowIm } = fft(rowScratch, rowFwdWorkspace);
+        for (let bf = 0; bf < blockFreq; bf++) {
+          nlmRowRe[tf * blockFreq + bf] = rowRe[bf];
+          nlmRowIm[tf * blockFreq + bf] = rowIm[bf];
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        for (let bf = 0; bf < blockFreq; bf++) {
+          colInRe[bf * blockTime + tf] = rawRowRe[tf * blockFreq + bf];
+          colInIm[bf * blockTime + tf] = rawRowIm[tf * blockFreq + bf];
+        }
+      }
+      for (let bf = 0; bf < blockFreq; bf++) {
+        for (let tf = 0; tf < blockTime; tf++) {
+          scratchRe[tf] = colInRe[bf * blockTime + tf];
+          scratchIm[tf] = colInIm[bf * blockTime + tf];
+        }
+        complexFft(scratchRe, scratchIm, scratchOutRe, scratchOutIm, colFwdWorkspaceA, colFwdWorkspaceB);
+        for (let tf = 0; tf < blockTime; tf++) {
+          rawColRe[bf * blockTime + tf] = scratchOutRe[tf];
+          rawColIm[bf * blockTime + tf] = scratchOutIm[tf];
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        for (let bf = 0; bf < blockFreq; bf++) {
+          colInRe[bf * blockTime + tf] = nlmRowRe[tf * blockFreq + bf];
+          colInIm[bf * blockTime + tf] = nlmRowIm[tf * blockFreq + bf];
+        }
+      }
+      for (let bf = 0; bf < blockFreq; bf++) {
+        for (let tf = 0; tf < blockTime; tf++) {
+          scratchRe[tf] = colInRe[bf * blockTime + tf];
+          scratchIm[tf] = colInIm[bf * blockTime + tf];
+        }
+        complexFft(scratchRe, scratchIm, scratchOutRe, scratchOutIm, colFwdWorkspaceA, colFwdWorkspaceB);
+        for (let tf = 0; tf < blockTime; tf++) {
+          nlmColRe[bf * blockTime + tf] = scratchOutRe[tf];
+          nlmColIm[bf * blockTime + tf] = scratchOutIm[tf];
+        }
+      }
+      const sigmaSq = threshold * threshold;
+      for (let bf = 0; bf < blockFreq; bf++) {
+        for (let tf = 0; tf < blockTime; tf++) {
+          const flatIdx = bf * blockTime + tf;
+          const nlmRe = nlmColRe[flatIdx];
+          const nlmIm = nlmColIm[flatIdx];
+          const nlmMagSq = nlmRe * nlmRe + nlmIm * nlmIm;
+          const gain = nlmMagSq / (nlmMagSq + sigmaSq);
+          gainColRe[flatIdx] = rawColRe[flatIdx] * gain;
+          gainColIm[flatIdx] = rawColIm[flatIdx] * gain;
+        }
+      }
+      for (let bf = 0; bf < blockFreq; bf++) {
+        for (let tf = 0; tf < blockTime; tf++) {
+          scratchRe[tf] = gainColRe[bf * blockTime + tf];
+          scratchIm[tf] = gainColIm[bf * blockTime + tf];
+        }
+        const icolResult = ifft(scratchRe, scratchIm, colInvWorkspace);
+        for (let tf = 0; tf < blockTime; tf++) {
+          colInRe[bf * blockTime + tf] = icolResult[tf];
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        for (let bf = 0; bf < blockFreq; bf++) {
+          rowScratchRe[bf] = colInRe[bf * blockTime + tf];
+          rowScratchIm[bf] = 0;
+        }
+        const irowResult = ifft(rowScratchRe, rowScratchIm, rowInvWorkspace);
+        for (let bf = 0; bf < blockFreq; bf++) {
+          synthBlock[tf * blockFreq + bf] = irowResult[bf];
+        }
+      }
+      for (let tf = 0; tf < blockTime; tf++) {
+        const destFrame = frameStart + tf;
+        if (destFrame >= numFrames) break;
+        for (let bf = 0; bf < blockFreq; bf++) {
+          const destBin = binStart + bf;
+          if (destBin >= numBins) break;
+          const winVal = win2d[tf * blockFreq + bf];
+          const destPos = destFrame * numBins + destBin;
+          accumulator[destPos] = accumulator[destPos] + synthBlock[tf * blockFreq + bf] * winVal;
+          windowSumSq[destPos] = windowSumSq[destPos] + winVal * winVal;
+        }
+      }
+    }
+  }
+  for (let flatIdx = 0; flatIdx < numFrames * numBins; flatIdx++) {
+    const ws = windowSumSq[flatIdx];
+    if (ws > 1e-8) {
+      const normalisedVal = accumulator[flatIdx] / ws;
+      output[flatIdx] = normalisedVal < 0 ? 0 : normalisedVal > 1 ? 1 : normalisedVal;
+    } else {
+      output[flatIdx] = rawMask[flatIdx];
+    }
+  }
+}
+function applyNlmSmoothingRange(mask, numFrames, numBins, nlmOptions, output, blockFrameStart, blockFrameEnd) {
+  const { patchSize, searchFreqRadius, searchTimePre, searchTimePost, pasteBlockSize, threshold } = nlmOptions;
+  const hSq = threshold * threshold;
+  const halfPatch = Math.floor(patchSize / 2);
+  for (let blockFrame = blockFrameStart; blockFrame < blockFrameEnd; blockFrame += pasteBlockSize) {
+    for (let blockBin = 0; blockBin < numBins; blockBin += pasteBlockSize) {
+      const centreFrame = blockFrame + Math.floor(pasteBlockSize / 2);
+      const centreBin = blockBin + Math.floor(pasteBlockSize / 2);
+      let weightSum = 0;
+      let valueSum = 0;
+      const timeStart = centreFrame - searchTimePre;
+      const timeEnd = centreFrame + searchTimePost;
+      const freqStart = centreBin - searchFreqRadius;
+      const freqEnd = centreBin + searchFreqRadius;
+      for (let candFrame = timeStart; candFrame <= timeEnd; candFrame++) {
+        const clampedCandFrame = candFrame < 0 ? 0 : candFrame >= numFrames ? numFrames - 1 : candFrame;
+        for (let candBin = freqStart; candBin <= freqEnd; candBin++) {
+          const clampedCandBin = candBin < 0 ? 0 : candBin >= numBins ? numBins - 1 : candBin;
+          let patchDistSq = 0;
+          for (let pf = -halfPatch; pf < halfPatch; pf++) {
+            for (let pb = -halfPatch; pb < halfPatch; pb++) {
+              const cf = centreFrame + pf;
+              const cBin = centreBin + pb;
+              const cf2 = cf < 0 ? 0 : cf >= numFrames ? numFrames - 1 : cf;
+              const cBin2 = cBin < 0 ? 0 : cBin >= numBins ? numBins - 1 : cBin;
+              const vCentre = mask[cf2 * numBins + cBin2];
+              const df = clampedCandFrame + pf;
+              const db = clampedCandBin + pb;
+              const df2 = df < 0 ? 0 : df >= numFrames ? numFrames - 1 : df;
+              const db2 = db < 0 ? 0 : db >= numBins ? numBins - 1 : db;
+              const vCand = mask[df2 * numBins + db2];
+              const diff = vCentre - vCand;
+              patchDistSq += diff * diff;
+            }
+          }
+          const weight = hSq > 0 ? Math.exp(-patchDistSq / hSq) : patchDistSq === 0 ? 1 : 0;
+          weightSum += weight;
+          valueSum += weight * mask[clampedCandFrame * numBins + clampedCandBin];
+        }
+      }
+      const smoothed = weightSum > 0 ? valueSum / weightSum : mask[centreFrame * numBins + centreBin];
+      for (let pf = 0; pf < pasteBlockSize; pf++) {
+        const outFrame = blockFrame + pf;
+        if (outFrame >= numFrames) break;
+        for (let pb = 0; pb < pasteBlockSize; pb++) {
+          const outBin = blockBin + pb;
+          if (outBin >= numBins) break;
+          output[outFrame * numBins + outBin] = smoothed;
+        }
+      }
+    }
+  }
+}
+
+export { AmplitudeHistogramAccumulator, BidirectionalIir, IntegratedLufsAccumulator, LoudnessAccumulator, MixedRadixFft, ResampleStream, SlidingWindowMaxStream, SlidingWindowMinStream, TruePeakAccumulator, TruePeakUpsampler, __commonJS, __export, __toESM, applyDfttSmoothing, applyNlmSmoothingRange, bandpass, createFftWorkspace, dbToLinear, deinterleaveBuffer, detectFftBackend, fft, getFftAddon, getLraConsideredStats, hanningWindow, initFftBackend, interleave, istft, linearToDb, stft };