audio 2.0.0-1 → 2.1.0

package/dist/audio.js

@@ -0,0 +1,3571 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn3, res) => function __init() {
+  return fn3 && (res = (0, fn3[__getOwnPropNames(fn3)[0]])(fn3 = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/audio-mic/browser.js
+var browser_exports = {};
+__export(browser_exports, {
+  default: () => mic
+});
+async function mic(opts = {}) {
+  const channels2 = opts.channels || 1;
+  const sampleRate2 = opts.sampleRate || 44100;
+  const bitDepth = opts.bitDepth || 16;
+  const constraints = {
+    audio: {
+      sampleRate: { ideal: sampleRate2 },
+      channelCount: { ideal: channels2 },
+      echoCancellation: opts.echoCancellation ?? false,
+      noiseSuppression: opts.noiseSuppression ?? false,
+      autoGainControl: opts.autoGainControl ?? false
+    }
+  };
+  const stream = await navigator.mediaDevices.getUserMedia(constraints);
+  const ownCtx = !opts.context;
+  const ctx = opts.context || new AudioContext({ sampleRate: sampleRate2 });
+  const source = ctx.createMediaStreamSource(stream);
+  let closed = false;
+  let pending = null;
+  let node;
+  if (ctx.audioWorklet) {
+    const workletCode = `
+      class MicProcessor extends AudioWorkletProcessor {
+        process(inputs) {
+          const input = inputs[0]
+          if (input && input.length > 0) {
+            const channels = []
+            for (let i = 0; i < input.length; i++) channels.push(input[i].slice())
+            this.port.postMessage(channels)
+          }
+          return true
+        }
+      }
+      registerProcessor('mic-processor', MicProcessor)
+    `;
+    const blob = new Blob([workletCode], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    await ctx.audioWorklet.addModule(url);
+    URL.revokeObjectURL(url);
+    node = new AudioWorkletNode(ctx, "mic-processor", {
+      numberOfInputs: 1,
+      numberOfOutputs: 0,
+      channelCount: channels2
+    });
+    source.connect(node);
+    node.port.onmessage = (e) => {
+      if (closed || !pending) return;
+      const cb = pending;
+      pending = null;
+      cb(null, float32ToPCM(e.data, bitDepth));
+    };
+  } else {
+    const bufSize = 2048;
+    node = ctx.createScriptProcessor(bufSize, channels2, 1);
+    source.connect(node);
+    node.connect(ctx.destination);
+    node.onaudioprocess = (e) => {
+      if (closed || !pending) return;
+      const cb = pending;
+      pending = null;
+      const chans = [];
+      for (let i = 0; i < channels2; i++) chans.push(e.inputBuffer.getChannelData(i).slice());
+      cb(null, float32ToPCM(chans, bitDepth));
+    };
+  }
+  read.close = close;
+  read.end = close;
+  read.backend = "mediastream";
+  return read;
+  function read(cb) {
+    if (cb == null || closed) {
+      close();
+      return;
+    }
+    if (ctx.state === "suspended") ctx.resume();
+    pending = cb;
+  }
+  function close() {
+    if (closed) return;
+    closed = true;
+    pending = null;
+    source.disconnect();
+    stream.getTracks().forEach((t) => t.stop());
+    if (ownCtx) ctx.close?.();
+  }
+  function float32ToPCM(channelData, bits) {
+    const ch = channelData.length;
+    const len = channelData[0].length;
+    const bps = bits / 8;
+    const buf = new Uint8Array(len * ch * bps);
+    const view = new DataView(buf.buffer);
+    for (let i = 0; i < len; i++) {
+      for (let c = 0; c < ch; c++) {
+        const sample = channelData[c][i];
+        const offset = (i * ch + c) * bps;
+        if (bits === 16) {
+          view.setInt16(offset, Math.max(-32768, Math.min(32767, Math.round(sample * 32767))), true);
+        } else if (bits === 32) {
+          view.setFloat32(offset, sample, true);
+        } else if (bits === 8) {
+          buf[offset] = Math.max(0, Math.min(255, Math.round((sample + 1) * 127.5)));
+        }
+      }
+    }
+    return buf;
+  }
+}
+var init_browser = __esm({
+  "node_modules/audio-mic/browser.js"() {
+  }
+});
+
+// node_modules/audio-type/audio-type.js
+function audioType(buf) {
+  if (!buf) return;
+  buf = new Uint8Array(buf.buffer || buf);
+  if (isWav(buf)) return "wav";
+  if (isAiff(buf)) return "aiff";
+  if (isMp3(buf)) return "mp3";
+  if (isAac(buf)) return "aac";
+  if (isFlac(buf)) return "flac";
+  if (isM4a(buf)) return "m4a";
+  if (isOpus(buf)) return "opus";
+  if (isOgg(buf)) return "oga";
+  if (isQoa(buf)) return "qoa";
+  if (isMidi(buf)) return "mid";
+  if (isCaf(buf)) return "caf";
+  if (isWma(buf)) return "wma";
+  if (isAmr(buf)) return "amr";
+  if (isWebm(buf)) return "webm";
+}
+function isMp3(buf) {
+  if (!buf || buf.length < 3) return;
+  return buf[0] === 73 && buf[1] === 68 && buf[2] === 51 || // ID3
+  buf[0] === 255 && (buf[1] & 224) === 224 && (buf[1] & 6) !== 0 || // MPEG sync, layer != 0 (excludes AAC)
+  buf[0] === 84 && buf[1] === 65 && buf[2] === 71;
+}
+function isWav(buf) {
+  if (!buf || buf.length < 12) return;
+  return buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 65 && buf[10] === 86 && buf[11] === 69;
+}
+function isOgg(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 79 && buf[1] === 103 && buf[2] === 103 && buf[3] === 83;
+}
+function isFlac(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 102 && buf[1] === 76 && buf[2] === 97 && buf[3] === 67;
+}
+function isM4a(buf) {
+  if (!buf || buf.length < 8) return;
+  return buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 || buf[0] === 77 && buf[1] === 52 && buf[2] === 65 && buf[3] === 32;
+}
+function isOpus(buf) {
+  if (!buf || buf.length < 36) return;
+  return buf[0] === 79 && buf[1] === 103 && buf[2] === 103 && buf[3] === 83 && buf[28] === 79 && buf[29] === 112 && buf[30] === 117 && buf[31] === 115 && buf[32] === 72 && buf[33] === 101 && buf[34] === 97 && buf[35] === 100;
+}
+function isQoa(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 113 && buf[1] === 111 && buf[2] === 97 && buf[3] === 102;
+}
+function isAiff(buf) {
+  if (!buf || buf.length < 12) return;
+  return buf[0] === 70 && buf[1] === 79 && buf[2] === 82 && buf[3] === 77 && buf[8] === 65 && buf[9] === 73 && buf[10] === 70 && (buf[11] === 70 || buf[11] === 67);
+}
+function isAac(buf) {
+  if (!buf || buf.length < 2) return;
+  return buf[0] === 255 && (buf[1] & 240) === 240 && (buf[1] & 6) === 0;
+}
+function isMidi(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 77 && buf[1] === 84 && buf[2] === 104 && buf[3] === 100;
+}
+function isCaf(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 99 && buf[1] === 97 && buf[2] === 102 && buf[3] === 102;
+}
+function isWma(buf) {
+  if (!buf || buf.length < 8) return;
+  return buf[0] === 48 && buf[1] === 38 && buf[2] === 178 && buf[3] === 117 && buf[4] === 142 && buf[5] === 102 && buf[6] === 207 && buf[7] === 17;
+}
+function isAmr(buf) {
+  if (!buf || buf.length < 5) return;
+  return buf[0] === 35 && buf[1] === 33 && buf[2] === 65 && buf[3] === 77 && buf[4] === 82;
+}
+function isWebm(buf) {
+  if (!buf || buf.length < 4) return;
+  return buf[0] === 26 && buf[1] === 69 && buf[2] === 223 && buf[3] === 163;
+}
+
+// node_modules/audio-decode/audio-decode.js
+var EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 });
+async function decode(src) {
+  if (!src || typeof src === "string" || !(src.buffer || src.byteLength || src.length))
+    throw TypeError("Expected ArrayBuffer or Uint8Array");
+  let buf = new Uint8Array(src);
+  let type = audioType(buf);
+  if (!type) throw Error("Unknown audio format");
+  if (!decode[type]) throw Error("No decoder for " + type);
+  let dec = await decode[type]();
+  try {
+    let result = await dec(buf);
+    let flushed = await dec();
+    return merge(result, flushed);
+  } catch (e) {
+    dec.free();
+    throw e;
+  }
+}
+function reg(name, load) {
+  decode[name] = fmt(name, async () => {
+    let mod = await load();
+    if (mod.decoder) {
+      let codec2 = await mod.decoder();
+      return streamDecoder(
+        (chunk) => codec2.decode(chunk),
+        codec2.flush ? () => codec2.flush() : null,
+        codec2.free ? () => codec2.free() : null
+      );
+    }
+    let init2 = mod.default || mod;
+    let codec = typeof init2 === "function" ? await init2() : init2;
+    if (codec.ready) await codec.ready;
+    return streamDecoder(
+      (chunk) => codec.decode(chunk),
+      codec.flush ? () => codec.flush() : null,
+      codec.free ? () => codec.free() : null
+    );
+  });
+}
+function fmt(name, init2) {
+  let fn3 = async (src) => {
+    if (!src) return init2();
+    console.warn("decode." + name + "(data) is deprecated, use decode(data) or let dec = await decode." + name + "()");
+    let dec = await init2();
+    try {
+      let result = await dec(src instanceof Uint8Array ? src : new Uint8Array(src.buffer || src));
+      let flushed = await dec();
+      return merge(result, flushed);
+    } catch (e) {
+      dec.free();
+      throw e;
+    }
+  };
+  fn3.stream = init2;
+  return fn3;
+}
+reg("mp3", () => import("mpg123-decoder").then((m2) => ({ decoder: async () => {
+  let d2 = new m2.MPEGDecoder();
+  await d2.ready;
+  return d2;
+} })));
+reg("flac", () => import("@wasm-audio-decoders/flac").then((m2) => ({ decoder: async () => {
+  let d2 = new m2.FLACDecoder();
+  await d2.ready;
+  return d2;
+} })));
+reg("opus", () => import("ogg-opus-decoder").then((m2) => ({ decoder: async () => {
+  let d2 = new m2.OggOpusDecoder();
+  await d2.ready;
+  return d2;
+} })));
+reg("oga", () => import("@wasm-audio-decoders/ogg-vorbis").then((m2) => ({ decoder: async () => {
+  let d2 = new m2.OggVorbisDecoder();
+  await d2.ready;
+  return d2;
+} })));
+reg("m4a", () => import("@audio/decode-aac"));
+reg("wav", () => import("@audio/decode-wav"));
+reg("qoa", () => import("qoa-format").then((m2) => ({ decoder: async () => ({ decode: (chunk) => m2.decode(chunk) }) })));
+reg("aac", () => import("@audio/decode-aac"));
+reg("aiff", () => import("@audio/decode-aiff"));
+reg("caf", () => import("@audio/decode-caf"));
+reg("webm", () => import("@audio/decode-webm"));
+reg("amr", () => import("@audio/decode-amr"));
+reg("wma", () => import("@audio/decode-wma"));
+function streamDecoder(onDecode, onFlush, onFree) {
+  let done = false;
+  let fn3 = async (chunk) => {
+    if (chunk) {
+      if (done) throw Error("Decoder already freed");
+      try {
+        return norm(await onDecode(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk)));
+      } catch (e) {
+        done = true;
+        onFree?.();
+        throw e;
+      }
+    }
+    if (done) return EMPTY;
+    done = true;
+    try {
+      let result = onFlush ? norm(await onFlush()) : EMPTY;
+      onFree?.();
+      return result;
+    } catch (e) {
+      onFree?.();
+      throw e;
+    }
+  };
+  fn3.decode = fn3;
+  fn3.flush = async () => {
+    if (done) return EMPTY;
+    return onFlush ? norm(await onFlush()) : EMPTY;
+  };
+  fn3.free = () => {
+    if (done) return;
+    done = true;
+    onFree?.();
+  };
+  return fn3;
+}
+function norm(r) {
+  if (!r?.channelData?.length) return EMPTY;
+  let { channelData, sampleRate: sampleRate2, samplesDecoded } = r;
+  if (samplesDecoded != null && samplesDecoded < channelData[0].length)
+    channelData = channelData.map((ch) => ch.subarray(0, samplesDecoded));
+  if (!channelData[0]?.length) return EMPTY;
+  if (channelData.length === 2) {
+    let a2 = channelData[0], b = channelData[1], same = true;
+    for (let i = 0; i < a2.length; i += 37) {
+      if (a2[i] !== b[i]) {
+        same = false;
+        break;
+      }
+    }
+    if (same) channelData = [a2];
+  }
+  return { channelData, sampleRate: sampleRate2 };
+}
+function merge(a2, b) {
+  if (!b?.channelData?.length) return a2;
+  if (!a2?.channelData?.length) return b;
+  let ach = a2.channelData.length, bch = b.channelData.length;
+  let ch = Math.max(ach, bch);
+  return {
+    channelData: Array.from({ length: ch }, (_, i) => {
+      let ac = a2.channelData[i % ach], bc = b.channelData[i % bch];
+      let merged = new Float32Array(ac.length + bc.length);
+      merged.set(ac);
+      merged.set(bc, ac.length);
+      return merged;
+    }),
+    sampleRate: a2.sampleRate
+  };
+}
+
+// node_modules/encode-audio/audio-encode.js
+var EMPTY2 = new Uint8Array(0);
+var encode = {};
+var audio_encode_default = encode;
+function reg2(name, load) {
+  encode[name] = fmt2(async (opts) => {
+    let init2 = (await load()).default;
+    let codec = await init2(opts);
+    return streamEncoder((ch) => codec.encode(ch), () => codec.flush(), () => codec.free());
+  });
+}
+reg2("wav", () => import("@audio/encode-wav"));
+reg2("aiff", () => import("@audio/encode-aiff"));
+reg2("mp3", () => import("@audio/encode-mp3"));
+reg2("ogg", () => import("@audio/encode-ogg"));
+reg2("flac", () => import("@audio/encode-flac"));
+reg2("opus", () => import("@audio/encode-opus"));
+function fmt2(init2) {
+  let fn3 = async (data, opts) => {
+    if (!opts) return init2(data);
+    if (!opts.sampleRate) throw Error("sampleRate is required");
+    let ch = channels(data);
+    if (!ch.length || !ch[0].length) return EMPTY2;
+    let enc = await init2({ channels: ch.length, ...opts });
+    try {
+      let result = await enc(ch);
+      let flushed = await enc();
+      return merge2(result, flushed);
+    } catch (e) {
+      enc.free();
+      throw e;
+    }
+  };
+  fn3.stream = init2;
+  return fn3;
+}
+function channels(data) {
+  if (!data) return [];
+  if (Array.isArray(data)) {
+    if (data[0] instanceof Float32Array) return data;
+    return [];
+  }
+  if (data instanceof Float32Array) return [data];
+  if (data.getChannelData && data.numberOfChannels) {
+    let ch = [];
+    for (let i = 0; i < data.numberOfChannels; i++) ch.push(data.getChannelData(i));
+    return ch;
+  }
+  return [];
+}
+function streamEncoder(onEncode, onFlush, onFree) {
+  let done = false;
+  let fn3 = async (data) => {
+    if (data) {
+      if (done) throw Error("Encoder already freed");
+      let ch = channels(data);
+      try {
+        return norm2(await onEncode(ch));
+      } catch (e) {
+        done = true;
+        onFree?.();
+        throw e;
+      }
+    }
+    if (done) return EMPTY2;
+    done = true;
+    try {
+      let result = onFlush ? norm2(await onFlush()) : EMPTY2;
+      onFree?.();
+      return result;
+    } catch (e) {
+      onFree?.();
+      throw e;
+    }
+  };
+  fn3.encode = fn3;
+  fn3.flush = async () => {
+    if (done) return EMPTY2;
+    return onFlush ? norm2(await onFlush()) : EMPTY2;
+  };
+  fn3.free = () => {
+    if (done) return;
+    done = true;
+    onFree?.();
+  };
+  return fn3;
+}
+function norm2(r) {
+  if (!r?.length) return EMPTY2;
+  if (r instanceof Uint8Array) return r;
+  if (r.buffer) return new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+  return new Uint8Array(r);
+}
+function merge2(a2, b) {
+  if (!b?.length) return a2 || EMPTY2;
+  if (!a2?.length) return b || EMPTY2;
+  let out = new Uint8Array(a2.length + b.length);
+  out.set(a2);
+  out.set(b, a2.length);
+  return out;
+}
+
+// node_modules/pcm-convert/index.js
+var sampleRate = [8e3, 11025, 16e3, 22050, 44100, 48e3, 88200, 96e3, 176400, 192e3, 352800, 384e3];
+var _AudioBuffer = typeof AudioBuffer !== "undefined" ? AudioBuffer : null;
+try {
+  _AudioBuffer ??= (await import("audio-buffer")).default;
+} catch {
+}
+var RATE_SET = new Set(sampleRate);
+var DTYPE = {
+  float32: { C: Float32Array, min: -1, max: 1 },
+  float64: { C: Float64Array, min: -1, max: 1 },
+  uint8: { C: Uint8Array, min: 0, max: 255 },
+  uint16: { C: Uint16Array, min: 0, max: 65535 },
+  uint32: { C: Uint32Array, min: 0, max: 4294967295 },
+  int8: { C: Int8Array, min: -128, max: 127 },
+  int16: { C: Int16Array, min: -32768, max: 32767 },
+  int32: { C: Int32Array, min: -2147483648, max: 2147483647 }
+};
+var dtype = (d2) => DTYPE[d2] && d2 || DTYPE[d2 + "32"] && d2 + "32";
+var CONTAINER = { array: 1, arraybuffer: 1, buffer: 1, audiobuffer: 1 };
+var CHANNELS = { mono: 1, stereo: 2, "2.1": 3, quad: 4, "5.1": 6 };
+for (let i = 3; i <= 32; i++) CHANNELS[i + "-channel"] ||= i;
+var CHANNEL_NAME = {};
+for (let k in CHANNELS) CHANNEL_NAME[CHANNELS[k]] ||= k;
+var isTyped = (v) => ArrayBuffer.isView(v) && !(v instanceof DataView);
+var isPlanar = (v) => Array.isArray(v) && v.length > 0 && isTyped(v[0]);
+var isContainer = (v) => v != null && typeof v !== "string" && !isPlanar(v) && (Array.isArray(v) || isTyped(v) || v instanceof ArrayBuffer);
+var isAudioBuffer = (v) => v != null && typeof v.getChannelData === "function" && typeof v.numberOfChannels === "number";
+function parse(fmt3) {
+  if (!fmt3) return {};
+  if (typeof fmt3 !== "string") {
+    let r2 = {};
+    let d2 = fmt3.dtype || fmt3.type;
+    if (dtype(d2)) r2.dtype = dtype(d2);
+    if (d2 && CONTAINER[d2]) r2.container = d2;
+    if (fmt3.channels != null) r2.channels = CHANNELS[fmt3.channels] || +fmt3.channels;
+    if (fmt3.numberOfChannels != null) r2.channels ??= fmt3.numberOfChannels;
+    if (fmt3.interleaved != null) r2.interleaved = fmt3.interleaved;
+    if (fmt3.endianness) r2.endianness = fmt3.endianness;
+    if (fmt3.sampleRate != null) r2.sampleRate = fmt3.sampleRate;
+    if (fmt3.rate != null) r2.sampleRate ??= fmt3.rate;
+    if (fmt3.container) r2.container = fmt3.container;
+    return r2;
+  }
+  let r = {};
+  for (let t of fmt3.split(/\s*[,;_]\s*|\s+/)) {
+    let lo = t.toLowerCase();
+    if (dtype(lo)) r.dtype = dtype(lo);
+    else if (CONTAINER[lo]) r.container = lo;
+    else if (CHANNELS[lo]) r.channels = CHANNELS[lo];
+    else if (lo === "interleaved") r.interleaved = true;
+    else if (lo === "planar") r.interleaved = false;
+    else if (lo === "le") r.endianness = "le";
+    else if (lo === "be") r.endianness = "be";
+    else if (/^\d+$/.test(lo) && RATE_SET.has(+lo)) r.sampleRate = +lo;
+    else throw Error("Unknown format token: " + t);
+  }
+  return r;
+}
+function detect(data) {
+  if (data == null) return {};
+  if (isAudioBuffer(data))
+    return { dtype: "float32", channels: data.numberOfChannels, interleaved: false, sampleRate: data.sampleRate };
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) return { dtype: "uint8", container: "buffer" };
+  if (data instanceof Float32Array) return { dtype: "float32" };
+  if (data instanceof Float64Array) return { dtype: "float64" };
+  if (data instanceof Int8Array) return { dtype: "int8" };
+  if (data instanceof Int16Array) return { dtype: "int16" };
+  if (data instanceof Int32Array) return { dtype: "int32" };
+  if (data instanceof Uint8Array) return { dtype: "uint8" };
+  if (data instanceof Uint8ClampedArray) return { dtype: "uint8" };
+  if (data instanceof Uint16Array) return { dtype: "uint16" };
+  if (data instanceof Uint32Array) return { dtype: "uint32" };
+  if (data instanceof ArrayBuffer) return { container: "arraybuffer" };
+  if (Array.isArray(data)) {
+    if (isPlanar(data))
+      return { ...detect(data[0]), channels: data.length, interleaved: false };
+    return { container: "array" };
+  }
+  return {};
+}
+function range(d2) {
+  return DTYPE[d2] || { min: -1, max: 1 };
+}
+function convert(src, from, to, dst) {
+  if (!src) throw Error("Source data required");
+  if (from == null) throw Error("Format required");
+  let srcInfo = detect(src);
+  if (to === void 0 && dst === void 0) {
+    if (isContainer(from)) {
+      dst = from;
+      to = detect(dst);
+      from = srcInfo;
+    } else {
+      to = parse(from);
+      from = srcInfo;
+    }
+  } else if (dst === void 0) {
+    if (isContainer(to)) {
+      dst = to;
+      to = parse(from);
+      from = srcInfo;
+    } else {
+      from = { ...srcInfo, ...parse(from) };
+      to = parse(to);
+    }
+  } else {
+    from = { ...srcInfo, ...parse(from) };
+    to = { ...dst ? detect(dst) : {}, ...parse(to) };
+  }
+  if (to.container === "audiobuffer") to.dtype = "float32";
+  if (!to.dtype) to.dtype = from.dtype;
+  if (to.channels == null && from.channels != null) to.channels = from.channels;
+  if (to.interleaved != null && from.interleaved == null) {
+    from.interleaved = !to.interleaved;
+    if (!from.channels) from.channels = 2;
+  }
+  if (from.interleaved != null && !from.channels) from.channels = 2;
+  let fromR = from.container === "array" ? { min: -1, max: 1 } : range(from.dtype);
+  let toR = to.container === "array" ? { min: -1, max: 1 } : range(to.dtype);
+  let samples;
+  if (isPlanar(src)) {
+    let ch2 = src.length, len2 = src[0].length;
+    samples = new src[0].constructor(len2 * ch2);
+    for (let c = 0; c < ch2; c++) samples.set(src[c], len2 * c);
+  } else if (isAudioBuffer(src)) {
+    let nc = src.numberOfChannels, len2 = src.length;
+    samples = new Float32Array(len2 * nc);
+    for (let c = 0; c < nc; c++) samples.set(src.getChannelData(c), len2 * c);
+  } else if (src instanceof ArrayBuffer) {
+    samples = new (DTYPE[from.dtype]?.C || Uint8Array)(src);
+  } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(src)) {
+    samples = new (DTYPE[from.dtype]?.C || Uint8Array)(
+      src.buffer.slice(src.byteOffset, src.byteOffset + src.byteLength)
+    );
+  } else {
+    samples = src;
+  }
+  let len = samples.length;
+  let needsMap = fromR.min !== toR.min || fromR.max !== toR.max;
+  let reinterleave = from.interleaved != null && to.interleaved != null && from.interleaved !== to.interleaved;
+  let ch = from.channels || 1, seg2 = Math.floor(len / ch);
+  let Ctor = DTYPE[to.dtype]?.C || Float32Array;
+  let out;
+  if (!needsMap && !reinterleave) {
+    out = to.container === "array" ? Array.from(samples) : new Ctor(samples);
+  } else {
+    out = to.container === "array" ? new Array(len) : new Ctor(len);
+    let fromSpan = fromR.max - fromR.min;
+    let toIsInt = toR.max > 1;
+    let toSpan = fromR.min === -1 && fromR.max === 1 && toIsInt ? toR.max - toR.min + 1 : toR.max - toR.min;
+    let roundInt = fromR.min === -1 && fromR.max === 1 && toIsInt;
+    if (!reinterleave) {
+      for (let i = 0; i < len; i++) {
+        let v = (samples[i] - fromR.min) / fromSpan * toSpan + toR.min;
+        if (roundInt) v = Math.round(v);
+        out[i] = v < toR.min ? toR.min : v > toR.max ? toR.max : v;
+      }
+    } else {
+      let deint = from.interleaved;
+      for (let i = 0; i < len; i++) {
+        let si = deint ? i % seg2 * ch + ~~(i / seg2) : i % ch * seg2 + ~~(i / ch);
+        let v = samples[si];
+        if (needsMap) {
+          v = (v - fromR.min) / fromSpan * toSpan + toR.min;
+          if (roundInt) v = Math.round(v);
+          if (v < toR.min) v = toR.min;
+          else if (v > toR.max) v = toR.max;
+        }
+        out[i] = v;
+      }
+    }
+  }
+  if (dst) {
+    if (Array.isArray(dst)) {
+      for (let i = 0; i < len; i++) dst[i] = out[i];
+      out = dst;
+    } else if (dst instanceof ArrayBuffer) {
+      let tc = new (DTYPE[to.dtype]?.C || Uint8Array)(dst);
+      tc.set(out);
+      out = tc;
+    } else {
+      dst.set(out);
+      out = dst;
+    }
+  }
+  let info = DTYPE[to.dtype];
+  if (info && info.C.BYTES_PER_ELEMENT > 1 && from.endianness && to.endianness && from.endianness !== to.endianness && out.buffer) {
+    let le = to.endianness === "le";
+    let view = new DataView(out.buffer);
+    let step = info.C.BYTES_PER_ELEMENT;
+    let fn3 = "set" + to.dtype[0].toUpperCase() + to.dtype.slice(1);
+    for (let i = 0; i < len; i++) view[fn3](i * step, out[i], le);
+  }
+  if (to.container === "audiobuffer") {
+    let ABCtor = typeof AudioBuffer !== "undefined" ? AudioBuffer : _AudioBuffer;
+    if (!ABCtor) throw Error("AudioBuffer not available. In Node.js: install audio-buffer package or set globalThis.AudioBuffer");
+    let ch2 = to.channels || 1, segLen = Math.floor(out.length / ch2);
+    let sr = to.sampleRate || from.sampleRate || 44100;
+    let ab = new ABCtor({ length: segLen, numberOfChannels: ch2, sampleRate: sr });
+    let interleaved = reinterleave ? to.interleaved : from.interleaved ?? false;
+    if (interleaved && ch2 > 1) {
+      for (let c = 0; c < ch2; c++) {
+        let data = new Float32Array(segLen);
+        for (let i = 0; i < segLen; i++) data[i] = out[i * ch2 + c];
+        ab.copyToChannel(data, c);
+      }
+    } else {
+      for (let c = 0; c < ch2; c++) ab.copyToChannel(out.subarray(c * segLen, (c + 1) * segLen), c);
+    }
+    return ab;
+  }
+  if (to.container === "arraybuffer" || to.container === "buffer") return out.buffer || out;
+  return out;
+}
+
+// node_modules/parse-duration/locale/en.js
+var unit = /* @__PURE__ */ Object.create(null);
+var m = 6e4;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
+unit.year = unit.yr = unit.y = y;
+unit.month = unit.mo = unit.mth = y / 12;
+unit.week = unit.wk = unit.w = d * 7;
+unit.day = unit.d = d;
+unit.hour = unit.hr = unit.h = h;
+unit.minute = unit.min = unit.m = m;
+unit.second = unit.sec = unit.s = 1e3;
+unit.millisecond = unit.millisec = unit.ms = 1;
+unit.microsecond = unit.microsec = unit.us = unit.\u00B5s = 1e-3;
+unit.nanosecond = unit.nanosec = unit.ns = 1e-6;
+unit.group = ",";
+unit.decimal = ".";
+unit.placeholder = " _";
+var en_default = unit;
+
+// node_modules/parse-duration/index.js
+var durationRE = /((?:\d{1,16}(?:\.\d{1,16})?|\.\d{1,16})(?:[eE][-+]?\d{1,4})?)\s?([\p{L}]{0,14})/gu;
+parse2.unit = en_default;
+function parse2(str = "", format = "ms") {
+  let result = null, prevUnits;
+  String(str).replace(new RegExp(`(\\d)[${parse2.unit.placeholder}${parse2.unit.group}](\\d)`, "g"), "$1$2").replace(parse2.unit.decimal, ".").replace(durationRE, (_, n, units) => {
+    if (!units) {
+      if (prevUnits) {
+        for (const u in parse2.unit) if (parse2.unit[u] < prevUnits) {
+          units = u;
+          break;
+        }
+      } else units = format;
+    } else units = units.toLowerCase();
+    prevUnits = units = parse2.unit[units] || parse2.unit[units.replace(/s$/, "")];
+    if (units) result = (result || 0) + n * units;
+  });
+  return result && result / (parse2.unit[format] || 1) * (str[0] === "-" ? -1 : 1);
+}
+
+// core.js
+audio.version = "2.1.0";
+function parseTime(v) {
+  if (v == null) return v;
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) throw new Error(`Invalid time: ${v}`);
+    return v;
+  }
+  let tc = v.match(/^(\d+):(\d{1,2})(?::(\d{1,2}))?(?:\.(\d+))?$/);
+  if (tc) {
+    let [, a2, b, c, frac] = tc;
+    let s2 = c != null ? +a2 * 3600 + +b * 60 + +c : +a2 * 60 + +b;
+    if (frac) s2 += +("0." + frac);
+    return s2;
+  }
+  let s = parse2(v, "s");
+  if (s != null && isFinite(s)) return s;
+  throw new Error(`Invalid time: ${v}`);
+}
+function audio(source, opts = {}) {
+  if (source == null) {
+    let sr = opts.sampleRate || 44100, ch = opts.channels || 1;
+    let waiters2 = [];
+    let notify2 = () => {
+      for (let w of waiters2.splice(0)) w();
+    };
+    let a3 = create([], sr, ch, 0, opts, null);
+    a3.decoded = false;
+    a3.recording = false;
+    a3._.acc = pageAccumulator({ pages: a3.pages, notify: notify2, ondata: (...args) => emit(a3, "data", ...args) });
+    a3._.waiters = waiters2;
+    return a3;
+  }
+  if (source && typeof source === "object" && !Array.isArray(source) && source.edits) {
+    if (!source.source) throw new TypeError("audio: cannot restore document without source reference");
+    let a3 = audio(source.source, opts);
+    if (a3.run) for (let e of source.edits) a3.run(e);
+    return a3;
+  }
+  if (Array.isArray(source) && source.length && !(source[0] instanceof Float32Array)) {
+    let instances = source.map((s) => s?.pages ? s : audio(s, opts));
+    let first = instances[0].clip ? instances[0].clip() : audio.from(instances[0]);
+    if (!first.insert) throw new Error('audio([...]): concat requires insert plugin \u2014 import "audio" instead of "audio/core.js"');
+    for (let i = 1; i < instances.length; i++) first.insert(instances[i]);
+    let loading = instances.filter((s) => !s.decoded);
+    if (loading.length) {
+      first.ready = Promise.all(loading.map((s) => s.ready)).then(() => {
+        delete first.then;
+        delete first.catch;
+        return true;
+      });
+      first.ready.catch(() => {
+      });
+      makeThenable(first);
+    }
+    return first;
+  }
+  if (source?.getChannelData && source?.numberOfChannels) return audio.from(source, opts);
+  if (Array.isArray(source) && source[0] instanceof Float32Array || typeof source === "number") {
+    let a3 = audio.from(source, opts);
+    if (audio.evict && a3.cache && a3.budget !== Infinity) {
+      a3.ready = audio.evict(a3).then(() => {
+        delete a3.then;
+        delete a3.catch;
+        return true;
+      });
+      a3.ready.catch(() => {
+      });
+      makeThenable(a3);
+    }
+    return a3;
+  }
+  let ref = typeof source === "string" ? source : source instanceof URL ? source.href : null;
+  let pages = [], waiters = [];
+  let notify = () => {
+    for (let w of waiters.splice(0)) w();
+  };
+  let a2 = create(pages, 0, 0, 0, { ...opts, source: ref }, null);
+  a2._.waiters = waiters;
+  a2.decoded = false;
+  let readyResolve, readyReject;
+  a2._.ready = new Promise((r, j) => {
+    readyResolve = r;
+    readyReject = j;
+  });
+  a2._.ready.catch(() => {
+  });
+  a2.ready = (async () => {
+    try {
+      if (opts.storage === "persistent") {
+        if (!audio.opfsCache) throw new Error('Persistent storage requires cache module (import "./cache.js")');
+        try {
+          opts = { ...opts, cache: await audio.opfsCache(), budget: opts.budget ?? audio.DEFAULT_BUDGET ?? Infinity };
+        } catch {
+          throw new Error('OPFS not available (required by storage: "persistent")');
+        }
+        a2.cache = opts.cache;
+        a2.budget = opts.budget;
+      }
+      let result = await decodeSource(source, { pages, notify, ondata: (...args) => emit(a2, "data", ...args) });
+      a2.sampleRate = result.sampleRate;
+      a2._.ch = result.channels;
+      a2._.chV = -1;
+      if (result.acc) a2._.acc = result.acc;
+      emit(a2, "metadata", { sampleRate: result.sampleRate, channels: result.channels });
+      readyResolve();
+      let final = await result.decoding;
+      a2._.len = final.length;
+      a2._.lenV = -1;
+      a2.stats = final.stats;
+      a2.decoded = true;
+      notify();
+      audio.evict?.(a2);
+      delete a2.then;
+      delete a2.catch;
+      return true;
+    } catch (e) {
+      readyReject(e);
+      throw e;
+    }
+  })();
+  a2.ready.catch(() => {
+  });
+  makeThenable(a2);
+  return a2;
+}
+function makeThenable(a2) {
+  a2.then = function(resolve, reject) {
+    return a2.ready.then(() => {
+      delete a2.then;
+      delete a2.catch;
+      return a2;
+    }).then(resolve, reject);
+  };
+  a2.catch = function(reject) {
+    return a2.then(null, reject);
+  };
+}
+audio.from = function(source, opts = {}) {
+  if (Array.isArray(source) && source[0] instanceof Float32Array) return fromChannels(source, opts);
+  if (typeof source === "number") return fromSilence(source, opts);
+  if (typeof source === "function") return fromFunction(source, opts);
+  if (source?.pages) {
+    return create(
+      source.pages,
+      opts.sampleRate ?? source.sampleRate,
+      opts.channels ?? source._.ch,
+      source._.len,
+      { source: source.source, storage: source.storage, cache: source.cache, budget: opts.budget ?? source.budget },
+      source.stats
+    );
+  }
+  if (source?.getChannelData) {
+    let chs = Array.from({ length: source.numberOfChannels }, (_, i) => new Float32Array(source.getChannelData(i)));
+    return fromChannels(chs, { sampleRate: source.sampleRate, ...opts });
+  }
+  if (ArrayBuffer.isView(source) && opts.format) {
+    let fmt3 = parse(opts.format);
+    let ch = fmt3.channels || opts.channels || 1;
+    let sr = fmt3.sampleRate || opts.sampleRate || 44100;
+    let src = { ...fmt3, channels: ch };
+    if (ch > 1 && src.interleaved == null) src.interleaved = true;
+    let pcm = convert(source, src, { dtype: "float32", interleaved: false, channels: ch });
+    let perCh = pcm.length / ch;
+    let chs = Array.from({ length: ch }, (_, c) => pcm.subarray(c * perCh, (c + 1) * perCh));
+    return fromChannels(chs, { sampleRate: sr });
+  }
+  throw new TypeError("audio.from: expected Float32Array[], AudioBuffer, audio instance, function, or number");
+};
+var fn = {};
+audio.fn = fn;
+audio.BLOCK_SIZE = 1024;
+audio.PAGE_SIZE = 1024 * audio.BLOCK_SIZE;
+var LOAD = /* @__PURE__ */ Symbol("load");
+var READ = /* @__PURE__ */ Symbol("read");
+function emit(a2, event, ...args) {
+  let arr = a2._.ev[event];
+  if (arr) for (let cb of arr) cb(...args);
+}
+fn.on = function(event, cb) {
+  (this._.ev[event] ??= []).push(cb);
+  return this;
+};
+fn.off = function(event, cb) {
+  if (!event) {
+    this._.ev = {};
+    return this;
+  }
+  if (!cb) {
+    delete this._.ev[event];
+    return this;
+  }
+  let arr = this._.ev[event];
+  if (arr) {
+    let i = arr.indexOf(cb);
+    if (i >= 0) arr.splice(i, 1);
+  }
+  return this;
+};
+fn.dispose = function() {
+  this.stop();
+  this._.ev = {};
+  this._.pcm = null;
+  this._.plan = null;
+  this.pages.length = 0;
+  this.stats = null;
+  this._.waiters = null;
+  this._.acc = null;
+};
+if (Symbol.dispose) fn[Symbol.dispose] = fn.dispose;
+audio.use = function(...plugins) {
+  for (let p of plugins) p(audio);
+};
+function create(pages, sampleRate2, ch, length, opts = {}, stats) {
+  let a2 = Object.create(fn);
+  a2.pages = pages;
+  a2.sampleRate = sampleRate2;
+  a2.source = opts.source ?? null;
+  a2.storage = opts.storage || "memory";
+  a2.cache = opts.cache || null;
+  a2.budget = opts.budget ?? Infinity;
+  a2.stats = stats;
+  a2.decoded = true;
+  a2.ready = Promise.resolve(true);
+  a2._ = {
+    ch,
+    // source channel count
+    len: length,
+    // source sample length
+    waiters: null,
+    // decode notify queue (null when not streaming)
+    ev: {},
+    // instance event listeners
+    ct: 0,
+    ctStamp: 0,
+    // currentTime wall-clock interpolation
+    vol: 1,
+    muted: false
+    // volume 0..1 linear with change events
+  };
+  a2.edits = [];
+  a2.version = 0;
+  a2._.pcm = null;
+  a2._.pcmV = -1;
+  a2._.plan = null;
+  a2._.planV = -1;
+  a2._.statsV = -1;
+  a2._.lenC = a2._.len;
+  a2._.lenV = 0;
+  a2._.chC = a2._.ch;
+  a2._.chV = 0;
+  Object.defineProperties(a2, {
+    currentTime: {
+      get() {
+        if (this.playing && !this.paused) {
+          let t = this._.ct + (performance.now() - this._.ctStamp) / 1e3;
+          let d2 = this.duration;
+          return d2 > 0 ? Math.min(t, d2) : t;
+        }
+        return this._.ct;
+      },
+      set(v) {
+        this._.ct = v;
+        this._.ctStamp = performance.now();
+      },
+      enumerable: true,
+      configurable: true
+    },
+    volume: {
+      get() {
+        return this._.vol;
+      },
+      set(v) {
+        v = Math.max(0, Math.min(1, +v || 0));
+        if (this._.vol !== v) {
+          this._.vol = v;
+          emit(this, "volumechange");
+        }
+      },
+      enumerable: true,
+      configurable: true
+    },
+    muted: {
+      get() {
+        return this._.muted;
+      },
+      set(v) {
+        v = !!v;
+        if (this._.muted !== v) {
+          this._.muted = v;
+          emit(this, "volumechange");
+        }
+      },
+      enumerable: true,
+      configurable: true
+    }
+  });
+  a2.playing = false;
+  a2.paused = false;
+  a2.ended = false;
+  a2.seeking = false;
+  a2.loop = false;
+  a2.block = null;
+  a2._.lru = /* @__PURE__ */ new Set();
+  return a2;
+}
+function fromChannels(channelData, opts = {}) {
+  let sr = opts.sampleRate || 44100;
+  return create(paginate(channelData), sr, channelData.length, channelData[0].length, opts, audio.statSession?.(sr).page(channelData).done());
+}
+function fromSilence(seconds, opts = {}) {
+  let sr = opts.sampleRate || 44100, ch = opts.channels || 1;
+  return fromChannels(Array.from({ length: ch }, () => new Float32Array(Math.round(seconds * sr))), { ...opts, sampleRate: sr });
+}
+function fromFunction(fn3, opts = {}) {
+  let sr = opts.sampleRate || 44100, ch = opts.channels || 1;
+  let dur = opts.duration;
+  if (dur == null) throw new TypeError("audio.from(fn): duration required");
+  let len = Math.round(dur * sr);
+  let chs = Array.from({ length: ch }, () => new Float32Array(len));
+  for (let i = 0; i < len; i++) {
+    let v = fn3(i / sr, i);
+    if (typeof v === "number") for (let c = 0; c < ch; c++) chs[c][i] = v;
+    else for (let c = 0; c < ch; c++) chs[c][i] = v[c] ?? 0;
+  }
+  return fromChannels(chs, { sampleRate: sr });
+}
+Object.defineProperties(fn, {
+  length: { get() {
+    return this._.len;
+  }, configurable: true },
+  duration: { get() {
+    return this.length / this.sampleRate;
+  }, configurable: true },
+  channels: { get() {
+    return this._.ch;
+  }, configurable: true }
+});
+fn[LOAD] = async function() {
+  if (this._.ready) await this._.ready;
+  this._.acc?.drain();
+};
+fn[READ] = function(offset, duration) {
+  return readPages(this, offset, duration);
+};
+fn.push = function(data, fmt3) {
+  let acc = this._.acc;
+  if (!acc) throw new Error("push: instance is not pushable \u2014 create with audio()");
+  let ch = this._.ch, sr = this.sampleRate;
+  let chData;
+  if (Array.isArray(data) && data[0] instanceof Float32Array) chData = data;
+  else if (data instanceof Float32Array) chData = [data];
+  else if (ArrayBuffer.isView(data)) {
+    let f = fmt3 || {};
+    let srcFmt = typeof f === "string" ? f : f.format || "int16";
+    let nch = f.channels || ch;
+    let src = { dtype: srcFmt, channels: nch };
+    if (nch > 1) src.interleaved = true;
+    let pcm = convert(data, src, { dtype: "float32", interleaved: false, channels: nch });
+    let perCh = pcm.length / nch;
+    chData = Array.from({ length: nch }, (_, c) => pcm.subarray(c * perCh, (c + 1) * perCh));
+  } else throw new TypeError("push: expected Float32Array[], Float32Array, or typed array");
+  if (!this._.ch) {
+    this._.ch = chData.length;
+    this._.chV = -1;
+  } else if (chData.length !== this._.ch) throw new TypeError(`push: expected ${this._.ch} channels, got ${chData.length}`);
+  acc.push(chData, fmt3 && fmt3.sampleRate || sr);
+  this._.len = acc.length;
+  this._.lenV = -1;
+  return this;
+};
+fn.stop = function() {
+  this.playing = false;
+  this.paused = false;
+  this.seeking = false;
+  if (this._._wake) this._._wake();
+  if (this.recording) {
+    this.recording = false;
+    if (this._._mic) {
+      this._._mic(null);
+      this._._mic = null;
+    }
+  }
+  if (this._.acc && !this.decoded) {
+    this._.acc.drain();
+    this.decoded = true;
+    if (this._.waiters) for (let w of this._.waiters.splice(0)) w();
+  }
+  return this;
+};
+fn.record = function(opts = {}) {
+  if (!this._.acc) throw new Error("record: instance is not pushable \u2014 create with audio()");
+  if (this.recording) return this;
+  this.recording = true;
+  this.decoded = false;
+  let self = this, sr = this.sampleRate, ch = this._.ch;
+  let _rec = (async () => {
+    try {
+      let { default: mic2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+      let read = mic2({ sampleRate: sr, channels: ch, bitDepth: 16, ...opts });
+      self._._mic = read;
+      read((err, buf) => {
+        if (!self.recording) return;
+        if (err || !buf) return;
+        self.push(new Int16Array(buf.buffer, buf.byteOffset, buf.byteLength / 2), "int16");
+      });
+    } catch (e) {
+      self.recording = false;
+      self.decoded = true;
+      if (self._.waiters) for (let w of self._.waiters.splice(0)) w();
+      throw e.code === "ERR_MODULE_NOT_FOUND" ? new Error("record: audio-mic not installed \u2014 npm i audio-mic") : e;
+    }
+  })();
+  _rec.catch(() => {
+  });
+  return this;
+};
+fn.seek = function(t) {
+  t = Math.max(0, t);
+  this.seeking = true;
+  this.currentTime = t;
+  if (this.cache) {
+    let page = Math.floor(t * this.sampleRate / audio.PAGE_SIZE);
+    (async () => {
+      for (let i = Math.max(0, page - 1); i <= Math.min(page + 2, this.pages.length - 1); i++)
+        if (this.pages[i] === null && await this.cache.has(i)) this.pages[i] = await this.cache.read(i);
+    })();
+  }
+  if (this.playing) {
+    this._._seekTo = t;
+    if (this._._wake) this._._wake();
+  } else this.seeking = false;
+  return this;
+};
+fn.read = async function(opts) {
+  if (typeof opts !== "object" || opts === null) opts = {};
+  let { at, duration, format, channel, meta } = opts;
+  at = parseTime(at);
+  duration = parseTime(duration);
+  await this[LOAD]();
+  let pcm = await this[READ](at, duration);
+  if (channel != null) pcm = [pcm[channel]];
+  if (!format) return channel != null ? pcm[0] : pcm;
+  let converted = audio_encode_default[format] ? await audio_encode_default[format](pcm, { sampleRate: this.sampleRate, ...meta }) : pcm.map((ch) => convert(ch, "float32", format));
+  return channel != null ? Array.isArray(converted) ? converted[0] : converted : converted;
+};
+function paginate(channelData) {
+  let len = channelData[0].length, pages = [];
+  for (let off = 0; off < len; off += audio.PAGE_SIZE)
+    pages.push(channelData.map((ch) => ch.subarray(off, Math.min(off + audio.PAGE_SIZE, len))));
+  return pages;
+}
+function walkPages(a2, c, srcOff, len, visitor) {
+  let p0 = Math.floor(srcOff / audio.PAGE_SIZE), pos = p0 * audio.PAGE_SIZE;
+  for (let p = p0; p < a2.pages.length && pos < srcOff + len; p++) {
+    let pg = a2.pages[p], pLen = pg ? pg[0].length : audio.PAGE_SIZE;
+    if (pos + pLen > srcOff && pg) {
+      let s = Math.max(srcOff - pos, 0), e = Math.min(srcOff + len - pos, pLen);
+      if (a2._.lru) {
+        a2._.lru.delete(p);
+        a2._.lru.add(p);
+      }
+      visitor(pg, c, s, e, Math.max(pos - srcOff, 0));
+    }
+    pos += pLen;
+  }
+}
+function copyPages(a2, c, srcOff, len, target, tOff) {
+  walkPages(a2, c, srcOff, len, (pg, ch, s, e, off) => target.set(pg[ch].subarray(s, e), tOff + off));
+}
+function readPages(a2, offset, duration) {
+  let sr = a2.sampleRate, ch = a2._.ch;
+  let s = offset != null ? Math.min(Math.max(Math.round(offset * sr), 0), a2._.len) : 0;
+  let len = duration != null ? Math.round(duration * sr) : a2._.len - s;
+  len = Math.min(Math.max(len, 0), a2._.len - s);
+  let out = Array.from({ length: ch }, () => new Float32Array(len));
+  for (let c = 0; c < ch; c++) copyPages(a2, c, s, len, out[c], 0);
+  return out;
+}
+async function resolveSource(source) {
+  if (source instanceof ArrayBuffer) return source;
+  if (source instanceof Uint8Array) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+  if (source instanceof URL) return resolveSource(source.href);
+  if (typeof source === "string") {
+    if (/^(https?|data|blob):/.test(source) || typeof window !== "undefined")
+      return (await fetch(source)).arrayBuffer();
+    if (source.startsWith("file:")) {
+      let { fileURLToPath } = await import("url");
+      source = fileURLToPath(source);
+    }
+    let { readFile } = await import("fs/promises");
+    let buf = await readFile(source);
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  throw new TypeError("audio: unsupported source type");
+}
+async function detectSource(source) {
+  if (source instanceof ArrayBuffer || source instanceof Uint8Array) {
+    let bytes2 = source instanceof ArrayBuffer ? new Uint8Array(source) : source.byteOffset || source.byteLength !== source.buffer.byteLength ? new Uint8Array(source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength)) : new Uint8Array(source.buffer);
+    return { format: audioType(bytes2), bytes: bytes2 };
+  }
+  if (typeof source === "string" && !/^(https?|data|blob):/.test(source) && typeof window === "undefined") {
+    let path = source;
+    if (source.startsWith("file:")) {
+      let { fileURLToPath } = await import("url");
+      path = fileURLToPath(source);
+    }
+    let { open } = await import("fs/promises");
+    let fh = await open(path, "r");
+    let hdr = new Uint8Array(12);
+    await fh.read(hdr, 0, 12, 0);
+    await fh.close();
+    let format = audioType(new Uint8Array(hdr));
+    let { createReadStream } = await import("fs");
+    return { format, reader: createReadStream(path) };
+  }
+  let buf = await resolveSource(source);
+  let bytes = new Uint8Array(buf);
+  return { format: audioType(bytes), bytes };
+}
+function pageAccumulator(opts = {}) {
+  let { pages = [], notify, ondata } = opts;
+  let sr = 0, ch = 0, totalLen = 0, pagePos = 0;
+  let pageBuf = null, session;
+  function emit2(page) {
+    pages.push(page);
+    totalLen += page[0].length;
+    notify?.();
+  }
+  return {
+    pages,
+    get sampleRate() {
+      return sr;
+    },
+    get channels() {
+      return ch;
+    },
+    get length() {
+      return totalLen + pagePos;
+    },
+    get partial() {
+      return pagePos > 0 ? pageBuf.map((c) => c.subarray(0, pagePos)) : null;
+    },
+    get partialLen() {
+      return pagePos;
+    },
+    push(chData, sampleRate2) {
+      if (!pageBuf) {
+        sr = sampleRate2;
+        ch = chData.length;
+        pageBuf = Array.from({ length: ch }, () => new Float32Array(audio.PAGE_SIZE));
+        session = audio.statSession?.(sr);
+      }
+      session?.page(chData);
+      let srcPos = 0, chunkLen = chData[0].length;
+      while (srcPos < chunkLen) {
+        let n = Math.min(chunkLen - srcPos, audio.PAGE_SIZE - pagePos);
+        for (let c = 0; c < ch; c++) pageBuf[c].set(chData[c].subarray(srcPos, srcPos + n), pagePos);
+        srcPos += n;
+        pagePos += n;
+        if (pagePos === audio.PAGE_SIZE) {
+          emit2(pageBuf);
+          pageBuf = Array.from({ length: ch }, () => new Float32Array(audio.PAGE_SIZE));
+          pagePos = 0;
+        }
+      }
+      if (ondata) {
+        let delta = session?.delta();
+        if (delta) ondata({ delta, offset: (totalLen + pagePos) / sr, sampleRate: sr, channels: ch, pages });
+      }
+      notify?.();
+    },
+    /** Flush partial page into pages array. Non-destructive — accumulator stays open. */
+    drain() {
+      if (pagePos > 0) {
+        emit2(pageBuf.map((c) => c.slice(0, pagePos)));
+        pageBuf = Array.from({ length: ch }, () => new Float32Array(audio.PAGE_SIZE));
+        pagePos = 0;
+      }
+    },
+    done() {
+      if (pagePos > 0) emit2(pageBuf.map((c) => c.slice(0, pagePos)));
+      session?.flush();
+      if (ondata && session) {
+        let delta = session.delta();
+        if (delta) ondata({ delta, offset: totalLen / sr, sampleRate: sr, channels: ch, pages });
+      }
+      return { stats: session?.done(), length: totalLen };
+    }
+  };
+}
+async function decodeSource(source, opts = {}) {
+  let { format, bytes, reader } = await detectSource(source);
+  if (!format || !decode[format]) {
+    if (!bytes) bytes = new Uint8Array(await resolveSource(source));
+    let { channelData, sampleRate: sampleRate2 } = await decode(bytes.buffer || bytes);
+    let pages = opts.pages || [];
+    let ps = paginate(channelData);
+    for (let p of ps) {
+      pages.push(p);
+      opts.notify?.();
+    }
+    let stats = audio.statSession?.(sampleRate2)?.page(channelData)?.done() ?? null;
+    return { pages, sampleRate: sampleRate2, channels: channelData.length, decoding: Promise.resolve({ stats, length: channelData[0].length }) };
+  }
+  let dec = await decode[format]();
+  let yieldLoop = () => new Promise((r) => setTimeout(r, 0));
+  let firstResolve;
+  let origNotify = opts.notify;
+  let firstReady = new Promise((r) => {
+    firstResolve = r;
+  });
+  let acc = pageAccumulator({
+    pages: opts.pages,
+    ondata: opts.ondata,
+    notify: () => {
+      origNotify?.();
+      if (firstResolve) {
+        let f = firstResolve;
+        firstResolve = null;
+        f();
+      }
+    }
+  });
+  let decoding = (async () => {
+    try {
+      if (reader) {
+        for await (let chunk of reader) {
+          let buf = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+          let r = await dec(buf);
+          if (r.channelData.length) acc.push(r.channelData, r.sampleRate);
+          await yieldLoop();
+        }
+      } else {
+        let FEED = 64 * 1024;
+        for (let off = 0; off < bytes.length; off += FEED) {
+          let r = await dec(bytes.subarray(off, Math.min(off + FEED, bytes.length)));
+          if (r.channelData.length) acc.push(r.channelData, r.sampleRate);
+          await yieldLoop();
+        }
+      }
+      let flushed = await dec();
+      if (flushed.channelData.length) acc.push(flushed.channelData, flushed.sampleRate);
+      let final = acc.done();
+      return final;
+    } catch (e) {
+      if (firstResolve) {
+        let f = firstResolve;
+        firstResolve = null;
+        f();
+      }
+      ;
+      throw e;
+    }
+  })();
+  await firstReady;
+  if (!acc.sampleRate) throw new Error("audio: decoded no audio data");
+  return { pages: acc.pages, sampleRate: acc.sampleRate, channels: acc.channels, decoding, acc };
+}
+
+// plan.js
+var fn2 = audio.fn;
+var ops = {};
+function seg(src, count, dst, rate, ref) {
+  let s = [src, count, dst];
+  if (rate != null && rate !== 1) s[3] = rate;
+  if (ref !== void 0) s[4] = ref;
+  return s;
+}
+function planOffset(offset, total, dflt = 0) {
+  let s = offset ?? dflt;
+  if (s < 0) s = total + s;
+  return Math.min(Math.max(0, s), total);
+}
+function opRange(ctx, len) {
+  let sr = ctx.sampleRate;
+  let s = ctx.at != null ? Math.round(ctx.at * sr) : 0;
+  return [s, ctx.duration != null ? s + Math.round(ctx.duration * sr) : len];
+}
+function isOpts(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) && !ArrayBuffer.isView(v) && !v.pages && !v.getChannelData;
+}
+audio.op = function(name, arg1, arg2, arg3) {
+  if (!arguments.length) return ops;
+  if (arguments.length === 1) return ops[name];
+  let desc;
+  if (typeof arg1 !== "function") {
+    desc = arg1;
+  } else {
+    let plan, opts;
+    if (typeof arg2 === "function") {
+      plan = arg2;
+      opts = arg3;
+    } else opts = arg2;
+    desc = { process: arg1 };
+    if (plan) desc.plan = plan;
+    if (opts) Object.assign(desc, opts);
+  }
+  if (!fn2[name] && !desc.hidden) {
+    let stdMethod = function(...a2) {
+      let edit = { type: name, args: a2 }, last = a2[a2.length - 1];
+      if (a2.length && isOpts(last)) {
+        let { at, duration, channel, offset, length, ...extra } = last;
+        edit.args = a2.slice(0, -1);
+        if (at != null) edit.at = parseTime(at);
+        if (duration != null) edit.duration = parseTime(duration);
+        if (offset != null) edit.offset = offset;
+        if (length != null) edit.length = length;
+        if (channel != null) edit.channel = channel;
+        Object.assign(edit, extra);
+      }
+      return this.run(edit);
+    };
+    fn2[name] = desc.call ? function(...a2) {
+      return desc.call.call(this, stdMethod, ...a2);
+    } : stdMethod;
+  }
+  ops[name] = desc;
+};
+function pushEdit(a2, edit) {
+  a2.edits.push(edit);
+  a2.version++;
+  emit(a2, "change");
+}
+function popEdit(a2) {
+  let e = a2.edits.pop();
+  if (e) {
+    a2.version++;
+    emit(a2, "change");
+  }
+  return e;
+}
+Object.defineProperties(fn2, {
+  length: { get() {
+    if (this._.lenV === this.version) return this._.lenC;
+    let len = this.edits.length ? buildPlan(this).totalLen : this._.len;
+    this._.lenC = len;
+    this._.lenV = this.version;
+    return len;
+  }, configurable: true },
+  channels: { get() {
+    if (this._.chV === this.version) return this._.chC;
+    let ch = this._.ch;
+    for (let edit of this.edits) {
+      if (ops[edit.type]?.ch) ch = ops[edit.type].ch(ch, edit.args);
+    }
+    this._.chC = ch;
+    this._.chV = this.version;
+    return ch;
+  }, configurable: true }
+});
+async function ensurePlan(a2, plan, offset, duration) {
+  if (!audio.ensurePages) return;
+  let { segs, sr } = plan;
+  let s = Math.round((offset || 0) * sr);
+  let e = duration != null ? s + Math.round(duration * sr) : plan.totalLen;
+  for (let sg of segs) {
+    let iStart = Math.max(s, sg[2]), iEnd = Math.min(e, sg[2] + sg[1]);
+    if (iStart >= iEnd) continue;
+    let absR = Math.abs(sg[3] || 1);
+    let srcStart = sg[0] + (iStart - sg[2]) * absR;
+    let srcLen = (iEnd - iStart) * absR + 1;
+    let target = sg[4] === null ? null : sg[4] || a2;
+    if (target) await audio.ensurePages(target, srcStart / sr, srcLen / sr);
+  }
+}
+async function loadRefs(a2) {
+  for (let { args } of a2.edits) if (args?.[0]?.pages) await args[0][LOAD]();
+}
+fn2[READ] = async function(offset, duration) {
+  if (!this.edits.length) {
+    if (audio.ensurePages) await audio.ensurePages(this, offset, duration);
+    return readPages(this, offset, duration);
+  }
+  await this[LOAD]();
+  await loadRefs(this);
+  let plan = buildPlan(this);
+  await ensurePlan(this, plan, offset, duration);
+  return readPlan(this, plan, offset, duration);
+};
+fn2[Symbol.asyncIterator] = fn2.stream = async function* (opts) {
+  let offset = parseTime(opts?.at), duration = parseTime(opts?.duration);
+  if (this._.waiters && !this.decoded && !this.edits.length) {
+    let sr = this.sampleRate, acc = this._.acc, PS = audio.PAGE_SIZE;
+    let startSample = offset ? Math.round(offset * sr) : 0;
+    let endSample = duration != null ? startSample + Math.round(duration * sr) : Infinity;
+    let pos = startSample;
+    while (pos < endSample) {
+      let available = acc ? this.pages.length * PS + acc.partialLen : this._.len;
+      while (pos >= available && !this.decoded) {
+        await new Promise((r) => this._.waiters.push(r));
+        available = acc ? this.pages.length * PS + acc.partialLen : this._.len;
+      }
+      if (pos >= available) break;
+      let end = Math.min(endSample, available);
+      let pi = Math.floor(pos / PS), po = pos % PS;
+      if (pi < this.pages.length) {
+        let page = this.pages[pi], e = Math.min(page[0].length - po, end - pos);
+        yield page.map((ch) => ch.subarray(po, po + e));
+        pos += e;
+      } else if (acc) {
+        let e = Math.min(acc.partialLen - po, end - pos);
+        if (e > 0) {
+          yield acc.partial.map((ch) => ch.subarray(po, po + e).slice());
+          pos += e;
+        }
+      }
+    }
+    return;
+  }
+  await this.ready;
+  await this[LOAD]();
+  await loadRefs(this);
+  let plan = buildPlan(this);
+  let seen = /* @__PURE__ */ new Set();
+  for (let s of plan.segs) if (s[4] && s[4] !== null && !seen.has(s[4])) {
+    seen.add(s[4]);
+    await s[4][LOAD]();
+  }
+  await ensurePlan(this, plan, offset, duration);
+  for (let chunk of streamPlan(this, plan, offset, duration)) yield chunk;
+};
+fn2.undo = function(n = 1) {
+  if (!this.edits.length) return n === 1 ? null : [];
+  let removed = [];
+  for (let i = 0; i < n && this.edits.length; i++) removed.push(popEdit(this));
+  return n === 1 ? removed[0] : removed;
+};
+fn2.run = function(...edits) {
+  let sr = this.sampleRate;
+  for (let e of edits) {
+    if (!e.type) throw new TypeError("audio.run: edit must have type");
+    let edit = { ...e, args: e.args || [] };
+    if (edit.at != null) edit.at = parseTime(edit.at);
+    if (edit.duration != null) edit.duration = parseTime(edit.duration);
+    if (edit.offset != null) {
+      edit.at = edit.offset / sr;
+      delete edit.offset;
+    }
+    if (edit.length != null) {
+      edit.duration = edit.length / sr;
+      delete edit.length;
+    }
+    pushEdit(this, edit);
+  }
+  return this;
+};
+fn2.toJSON = function() {
+  let edits = this.edits.filter((e) => !e.args?.some((a2) => typeof a2 === "function"));
+  return { source: this.source, edits, sampleRate: this.sampleRate, channels: this.channels, duration: this.duration };
+};
+fn2.clone = function() {
+  let b = audio.from(this);
+  for (let e of this.edits) pushEdit(b, { ...e });
+  return b;
+};
+var MAX_FLAT_SIZE = 2 ** 29;
+function render(a2, offset, count) {
+  if (Array.isArray(a2) && a2[0] instanceof Float32Array) {
+    return offset != null ? a2.map((ch) => ch.subarray(offset, offset + count)) : a2;
+  }
+  if (a2?.getChannelData && !a2.pages) {
+    let chs = Array.from({ length: a2.numberOfChannels }, (_, i) => new Float32Array(a2.getChannelData(i)));
+    return offset != null ? chs.map((ch) => ch.subarray(offset, offset + count)) : chs;
+  }
+  if (offset != null) return readRange(a2, offset, count);
+  if (a2._.pcm && a2._.pcmV === a2.version) return a2._.pcm;
+  if (!a2.edits.length) {
+    let r2 = readPages(a2);
+    a2._.pcm = r2;
+    a2._.pcmV = a2.version;
+    return r2;
+  }
+  let plan = buildPlan(a2);
+  let virtualLen = planLen(plan.segs);
+  if (virtualLen > MAX_FLAT_SIZE) throw new Error(`Audio too large for flat render (${(virtualLen / 1e6).toFixed(0)}M samples). Use streaming.`);
+  let r = readPlan(a2, plan);
+  a2._.pcm = r;
+  a2._.pcmV = a2.version;
+  return r;
+}
+function planLen(segs) {
+  let m2 = 0;
+  for (let s of segs) m2 = Math.max(m2, s[2] + s[1]);
+  return m2;
+}
+function buildPlan(a2) {
+  if (a2._.plan && a2._.planV === a2.version) return a2._.plan;
+  let sr = a2.sampleRate, ch = a2._.ch;
+  let segs = [[0, a2._.len, 0]], pipeline = [];
+  for (let edit of a2.edits) {
+    let { type, args = [], at, duration, channel, ...extra } = edit;
+    let op = ops[type];
+    if (!op) throw new Error(`Unknown op: ${type}`);
+    if (op.resolve) {
+      let ctx = { ...extra, stats: a2._.srcStats || a2.stats, sampleRate: sr, channelCount: ch, channel, at, duration, totalDuration: planLen(segs) / sr };
+      let resolved2 = op.resolve(args, ctx);
+      if (resolved2 === false) continue;
+      if (resolved2) {
+        let edits = Array.isArray(resolved2) ? resolved2 : [resolved2];
+        for (let r of edits) {
+          if (channel != null && r.channel == null) r.channel = channel;
+          if (at != null && r.at == null) r.at = at;
+          if (duration != null && r.duration == null) r.duration = duration;
+          let rOp = ops[r.type];
+          if (rOp?.plan && typeof rOp.plan === "function") {
+            let t = planLen(segs), rOffset = r.at != null ? Math.round(r.at * sr) : null, rLength = r.duration != null ? Math.round(r.duration * sr) : null;
+            segs = rOp.plan(segs, { total: t, sampleRate: sr, args: r.args || [], offset: rOffset, length: rLength });
+          } else {
+            pipeline.push(r);
+          }
+        }
+        continue;
+      }
+    }
+    if (op.plan) {
+      let t = planLen(segs), offset = at != null ? Math.round(at * sr) : null, length = duration != null ? Math.round(duration * sr) : null;
+      segs = op.plan(segs, { total: t, sampleRate: sr, args, offset, length });
+    } else {
+      pipeline.push(edit);
+    }
+  }
+  let plan = { segs, pipeline, totalLen: planLen(segs), sr };
+  a2._.plan = plan;
+  a2._.planV = a2.version;
+  return plan;
+}
+var _rsBuf = null;
+var _rsLen = 0;
+function readSource(a2, c, srcOff, n, target, tOff, rate) {
+  let r = rate || 1, absR = Math.abs(r);
+  if (absR === 1) {
+    if (r > 0) return copyPages(a2, c, srcOff, n, target, tOff);
+    return walkPages(a2, c, srcOff, n, (pg, ch, s, e, off) => {
+      for (let i = s; i < e; i++) target[tOff + (n - 1 - (off + i - s))] = pg[ch][i];
+    });
+  }
+  let srcN = Math.ceil(n * absR) + 1;
+  if (srcN > _rsLen) {
+    _rsLen = srcN;
+    _rsBuf = new Float32Array(srcN);
+  }
+  let buf = _rsBuf.subarray(0, srcN);
+  buf.fill(0);
+  copyPages(a2, c, srcOff, srcN, buf, 0);
+  resample(buf, target, tOff, n, r);
+}
+function resample(src, target, tOff, n, rate) {
+  let absR = Math.abs(rate), rev = rate < 0;
+  for (let i = 0; i < n; i++) {
+    let pos = (rev ? n - 1 - i : i) * absR;
+    let idx = pos | 0, frac = pos - idx;
+    target[tOff + i] = idx + 1 < src.length ? src[idx] + (src[idx + 1] - src[idx]) * frac : src[idx] || 0;
+  }
+}
+function readRange(a2, srcStart, n) {
+  if (!a2.edits.length) {
+    return Array.from({ length: a2._.ch }, (_, c) => {
+      let out = new Float32Array(n);
+      copyPages(a2, c, srcStart, n, out, 0);
+      return out;
+    });
+  }
+  let plan = buildPlan(a2), sr = plan.sr;
+  return readPlan(a2, plan, srcStart / sr, n / sr);
+}
+function* streamPlan(a2, plan, offset, duration) {
+  let { segs, pipeline, totalLen, sr } = plan;
+  let s = Math.round((offset || 0) * sr), e = duration != null ? s + Math.round(duration * sr) : totalLen;
+  let totalDur = totalLen / sr;
+  let procs = pipeline.map((ed) => {
+    let m2 = ops[ed.type];
+    let { type, args, at, duration: duration2, channel, ...extra } = ed;
+    return {
+      op: m2.process,
+      at: at != null && at < 0 ? totalDur + at : at,
+      dur: duration2,
+      channel,
+      ctx: { ...extra, args: args || [], duration: duration2, sampleRate: sr, totalDuration: totalDur, render }
+    };
+  });
+  let WARMUP = 8;
+  let ws = s > 0 && procs.length ? Math.max(0, s - audio.BLOCK_SIZE * WARMUP) : s;
+  for (let outOff = ws; outOff < e; outOff += audio.BLOCK_SIZE) {
+    let blockEnd = outOff < s ? s : e;
+    let len = Math.min(audio.BLOCK_SIZE, blockEnd - outOff);
+    let chunk = Array.from({ length: a2._.ch }, () => new Float32Array(len));
+    for (let sg of segs) {
+      let iStart = Math.max(outOff, sg[2]), iEnd = Math.min(outOff + len, sg[2] + sg[1]);
+      if (iStart >= iEnd) continue;
+      let rate = sg[3] || 1, ref = sg[4], absR = Math.abs(rate);
+      let n = iEnd - iStart, dstOff = iStart - outOff;
+      let srcStart = rate < 0 ? sg[0] + (sg[1] - (iStart - sg[2]) - n) * absR : sg[0] + (iStart - sg[2]) * absR;
+      if (ref === null) {
+      } else if (ref) {
+        if (ref.edits.length === 0) {
+          for (let c = 0; c < a2._.ch; c++)
+            readSource(ref, c % ref._.ch, srcStart, n, chunk[c], dstOff, rate);
+        } else {
+          let srcN = Math.ceil(n * absR) + 1;
+          let srcPcm = readRange(ref, srcStart, srcN);
+          for (let c = 0; c < a2._.ch; c++) {
+            let src = srcPcm[c % srcPcm.length];
+            if (absR === 1) {
+              if (rate < 0) {
+                for (let i = 0; i < n; i++) chunk[c][dstOff + i] = src[n - 1 - i];
+              } else chunk[c].set(src.subarray(0, n), dstOff);
+            } else resample(src, chunk[c], dstOff, n, rate);
+          }
+        }
+      } else {
+        for (let c = 0; c < a2._.ch; c++) readSource(a2, c, srcStart, n, chunk[c], dstOff, rate);
+      }
+    }
+    let blockOff = outOff / sr;
+    for (let proc of procs) {
+      let { op, at, channel, ctx } = proc;
+      if (!op) continue;
+      ctx.at = at != null ? at - blockOff : void 0;
+      ctx.blockOffset = blockOff;
+      if (channel != null) {
+        let chs = typeof channel === "number" ? [channel] : channel;
+        let sub = chs.map((c) => chunk[c]);
+        let result = op(sub, ctx);
+        if (result && result !== false) for (let i = 0; i < chs.length; i++) chunk[chs[i]] = result[i];
+      } else {
+        let result = op(chunk, ctx);
+        if (result === false || result === null) continue;
+        if (result) chunk = result;
+      }
+    }
+    if (outOff >= s) yield chunk;
+  }
+}
+function readPlan(a2, plan, offset, duration) {
+  let chunks = [];
+  for (let chunk of streamPlan(a2, plan, offset, duration)) chunks.push(chunk);
+  if (!chunks.length) return Array.from({ length: a2.channels }, () => new Float32Array(0));
+  let ch = chunks[0].length, totalLen = chunks.reduce((n, c) => n + c[0].length, 0);
+  return Array.from({ length: ch }, (_, c) => {
+    let out = new Float32Array(totalLen), pos = 0;
+    for (let chunk of chunks) {
+      out.set(chunk[c], pos);
+      pos += chunk[0].length;
+    }
+    return out;
+  });
+}
+
+// cache.js
+var DEFAULT_BUDGET = 500 * 1024 * 1024;
+async function evict(a2) {
+  if (!a2.cache || a2.budget === Infinity) return;
+  let bytes = (p) => p ? p.reduce((s, ch) => s + ch.byteLength, 0) : 0;
+  let current = a2.pages.reduce((sum, p) => sum + bytes(p), 0);
+  if (current <= a2.budget) return;
+  let order = a2._.lru && a2._.lru.size ? [...a2._.lru] : a2.pages.map((_, i) => i);
+  for (let i of order) {
+    if (current <= a2.budget) break;
+    if (!a2.pages[i]) continue;
+    await a2.cache.write(i, a2.pages[i]);
+    current -= bytes(a2.pages[i]);
+    a2.pages[i] = null;
+    if (a2._.lru) a2._.lru.delete(i);
+  }
+}
+async function ensurePages(a2, offset, duration) {
+  if (!a2.cache) return;
+  let PS = audio.PAGE_SIZE, sr = a2.sampleRate;
+  let s = offset != null ? Math.max(0, Math.round(offset * sr)) : 0;
+  let len = duration != null ? Math.round(duration * sr) : a2._.len - s;
+  let p0 = Math.floor(s / PS), pEnd = Math.min(Math.ceil((s + len) / PS), a2.pages.length);
+  for (let i = p0; i < pEnd; i++)
+    if (a2.pages[i] === null && await a2.cache.has(i)) a2.pages[i] = await a2.cache.read(i);
+}
+async function opfsCache(dirName = "audio-cache") {
+  if (typeof navigator === "undefined" || !navigator.storage?.getDirectory)
+    throw new Error("OPFS not available in this environment");
+  let root = await navigator.storage.getDirectory();
+  let dir = await root.getDirectoryHandle(dirName, { create: true });
+  return {
+    async read(i) {
+      let handle = await dir.getFileHandle(`p${i}`);
+      let file = await handle.getFile();
+      let buf = await file.arrayBuffer();
+      let view = new Float32Array(buf);
+      let ch = view[0] | 0, samplesPerCh = (view.length - 1) / ch | 0;
+      let data = [];
+      for (let c = 0; c < ch; c++) data.push(view.slice(1 + c * samplesPerCh, 1 + (c + 1) * samplesPerCh));
+      return data;
+    },
+    async write(i, data) {
+      let handle = await dir.getFileHandle(`p${i}`, { create: true });
+      let writable = await handle.createWritable();
+      let total = 1 + data.reduce((s, ch) => s + ch.length, 0);
+      let packed = new Float32Array(total);
+      packed[0] = data.length;
+      let off = 1;
+      for (let ch of data) {
+        packed.set(ch, off);
+        off += ch.length;
+      }
+      await writable.write(packed.buffer);
+      await writable.close();
+    },
+    has(i) {
+      return dir.getFileHandle(`p${i}`).then(() => true, () => false);
+    },
+    async evict(i) {
+      try {
+        await dir.removeEntry(`p${i}`);
+      } catch {
+      }
+    },
+    async clear() {
+      for await (let [name] of dir) await dir.removeEntry(name);
+    }
+  };
+}
+audio.opfsCache = opfsCache;
+audio.evict = evict;
+audio.ensurePages = ensurePages;
+audio.DEFAULT_BUDGET = DEFAULT_BUDGET;
+
+// stats.js
+var statDefs = {};
+audio.stat = function(name, desc) {
+  if (!arguments.length) return statDefs;
+  if (arguments.length === 1) return statDefs[name];
+  if (typeof desc === "function") desc = { block: desc };
+  statDefs[name] = desc;
+};
+function statSession(sr) {
+  let fns, acc, ch, last = 0, rem = null, remLen = 0;
+  function init2(c) {
+    ch = c;
+    fns = Object.entries(audio.stat()).filter(([_, d2]) => d2.block).map(([name, d2]) => ({ name, fn: d2.block, ctx: { sampleRate: sr } }));
+    acc = /* @__PURE__ */ Object.create(null);
+    for (let { name } of fns) acc[name] = Array.from({ length: ch }, () => []);
+  }
+  function processBlock(block) {
+    for (let { name, fn: fn3, ctx } of fns) {
+      let v = fn3(block, ctx);
+      if (typeof v === "number") for (let c = 0; c < ch; c++) acc[name][c].push(v);
+      else for (let c = 0; c < ch; c++) acc[name][c].push(v[c]);
+    }
+  }
+  return {
+    page(page) {
+      if (!acc) init2(page.length);
+      let BS = audio.BLOCK_SIZE, off = 0, len = page[0].length;
+      if (remLen > 0) {
+        let need = BS - remLen;
+        if (len >= need) {
+          for (let c = 0; c < ch; c++) rem[c].set(page[c].subarray(0, need), remLen);
+          processBlock(rem);
+          off = need;
+          remLen = 0;
+        } else {
+          for (let c = 0; c < ch; c++) rem[c].set(page[c].subarray(0, len), remLen);
+          remLen += len;
+          return this;
+        }
+      }
+      while (off + BS <= len) {
+        processBlock(Array.from({ length: ch }, (_, c) => page[c].subarray(off, off + BS)));
+        off += BS;
+      }
+      if (off < len) {
+        if (!rem) rem = Array.from({ length: ch }, () => new Float32Array(BS));
+        for (let c = 0; c < ch; c++) rem[c].set(page[c].subarray(off));
+        remLen = len - off;
+      }
+      return this;
+    },
+    /** Flush any buffered partial block as a short final block. */
+    flush() {
+      if (remLen > 0) {
+        processBlock(Array.from({ length: ch }, (_, c) => rem[c].subarray(0, remLen)));
+        remLen = 0;
+      }
+    },
+    delta() {
+      if (!acc) return;
+      let firstKey = Object.keys(acc)[0];
+      if (!firstKey) return;
+      let cur = acc[firstKey][0].length;
+      if (cur <= last) return;
+      let d2 = { fromBlock: last };
+      for (let name in acc) d2[name] = acc[name].map((a2) => new Float32Array(a2.slice(last)));
+      last = cur;
+      return d2;
+    },
+    done() {
+      this.flush();
+      let out = { blockSize: audio.BLOCK_SIZE };
+      if (acc) for (let name in acc) out[name] = acc[name].map((a2) => new Float32Array(a2));
+      return out;
+    }
+  };
+}
+function binReduce(src, from, to, bins, reduce) {
+  if (bins <= 0 || to <= from) return new Float32Array(Math.max(0, bins));
+  from = Math.max(0, from);
+  to = Math.min(to, src.length);
+  if (to <= from) return new Float32Array(bins);
+  let out = new Float32Array(bins), bpp = (to - from) / bins;
+  for (let i = 0; i < bins; i++) {
+    let a2 = from + Math.floor(i * bpp), b = Math.min(from + Math.floor((i + 1) * bpp), to);
+    if (b <= a2) b = a2 + 1;
+    out[i] = reduce(src, a2, b);
+  }
+  return out;
+}
+function remapStats(srcStats, plan, sr) {
+  let bs = srcStats.blockSize, segs = plan.segs, totalLen = plan.totalLen;
+  for (let s of segs) {
+    let rate = s[3] || 1, ref = s[4];
+    if (ref !== void 0 && ref !== null) return null;
+    if (Math.abs(rate) !== 1) return null;
+    if (s[0] % bs !== 0 || s[2] % bs !== 0) return null;
+  }
+  let outBlocks = Math.ceil(totalLen / bs);
+  let fields = Object.keys(srcStats).filter((k) => k !== "blockSize" && Array.isArray(srcStats[k]));
+  let ch = srcStats[fields[0]]?.length || 1;
+  let out = { blockSize: bs };
+  for (let f of fields) out[f] = Array.from({ length: ch }, () => new Float32Array(outBlocks));
+  for (let s of segs) {
+    let srcOff = s[0], count = s[1], dstOff = s[2], rate = s[3] || 1, ref = s[4];
+    let dstBlockStart = Math.floor(dstOff / bs);
+    let dstBlockEnd = Math.ceil((dstOff + count) / bs);
+    if (ref === null) continue;
+    let srcBlockStart = Math.floor(srcOff / bs);
+    let srcBlocks = srcStats[fields[0]][0].length;
+    let rev = rate < 0;
+    for (let i = dstBlockStart; i < dstBlockEnd && i < outBlocks; i++) {
+      let si = rev ? srcBlockStart + (dstBlockEnd - 1 - i) : srcBlockStart + (i - dstBlockStart);
+      if (si < 0 || si >= srcBlocks) continue;
+      for (let f of fields) for (let c = 0; c < ch; c++) out[f][c][i] = srcStats[f][c][si];
+    }
+  }
+  return out;
+}
+audio.statSession = statSession;
+async function queryRange(inst, opts) {
+  await inst[LOAD]();
+  let at = parseTime(opts?.at), dur = parseTime(opts?.duration);
+  let hasRange = at != null || dur != null;
+  if (inst.edits?.length && inst._.statsV !== inst.version) {
+    if (!inst._.srcStats) inst._.srcStats = inst.stats;
+    if (hasRange) {
+      let plan2 = buildPlan(inst);
+      await ensurePlan(inst, plan2, at || 0, dur);
+      let s = statSession(inst.sampleRate);
+      for (let chunk of streamPlan(inst, plan2, at || 0, dur)) s.page(chunk);
+      let stats = s.done();
+      let first2 = Object.values(stats).find((v) => v?.[0]?.length);
+      let blocks2 = first2?.[0]?.length || 0;
+      return { stats, ch: inst.channels, sr: inst.sampleRate, from: 0, to: blocks2 };
+    }
+    let plan = buildPlan(inst);
+    if (!plan.pipeline.length && inst._.srcStats?.blockSize) {
+      let remapped = remapStats(inst._.srcStats, plan, inst.sampleRate);
+      if (remapped) {
+        inst.stats = remapped;
+        inst._.statsV = inst.version;
+      } else {
+        let s = statSession(inst.sampleRate);
+        await ensurePlan(inst, plan);
+        for (let chunk of streamPlan(inst, plan)) s.page(chunk);
+        inst.stats = s.done();
+        inst._.statsV = inst.version;
+      }
+    } else {
+      let s = statSession(inst.sampleRate);
+      await ensurePlan(inst, plan);
+      for (let chunk of streamPlan(inst, plan)) s.page(chunk);
+      inst.stats = s.done();
+      inst._.statsV = inst.version;
+    }
+  }
+  let sr = inst.sampleRate, bs = inst.stats?.blockSize;
+  if (!bs) return { stats: inst.stats, ch: inst.channels, sr, from: 0, to: 0 };
+  let first = Object.values(inst.stats).find((v) => v?.[0]?.length);
+  let blocks = first?.[0]?.length || 0;
+  let atN = at != null && at < 0 ? inst.duration + at : at;
+  let from = atN != null ? Math.floor(atN * sr / bs) : 0;
+  let to = dur != null ? Math.ceil(((atN || 0) + dur) * sr / bs) : blocks;
+  from = Math.max(0, Math.min(from, blocks));
+  to = Math.max(from, Math.min(to, blocks));
+  return { stats: inst.stats, ch: inst.channels, sr, from, to };
+}
+audio.fn.stat = async function(name, opts) {
+  if (Array.isArray(name)) return Promise.all(name.map((n) => this.stat(n, opts)));
+  if (typeof this[name] === "function" && !audio.stat(name)) return this[name](opts);
+  let { stats, ch, sr, from, to } = await queryRange(this, opts);
+  let bins = opts?.bins;
+  let chSel = opts?.channel;
+  let perCh = Array.isArray(chSel);
+  let chs = chSel != null ? perCh ? chSel : [chSel] : Array.from({ length: ch }, (_, i) => i);
+  let desc = audio.stat(name);
+  if (desc?.query && bins == null) return desc.query(stats, chs, from, to, sr);
+  let src = stats[name], reduce = desc?.reduce;
+  if (!src) throw new Error(`Unknown stat: '${name}'`);
+  if (!reduce) throw new Error(`No reducer for stat: '${name}'`);
+  if (bins != null) {
+    let n = bins ?? to - from;
+    let reduce1 = (c) => binReduce(src[c], from, to, n, reduce);
+    if (perCh) return chs.map(reduce1);
+    if (chs.length === 1) return reduce1(chs[0]);
+    let out = new Float32Array(n), bpp = (to - from) / n;
+    for (let i = 0; i < n; i++) {
+      let a2 = from + Math.floor(i * bpp), b = Math.min(from + Math.floor((i + 1) * bpp), to);
+      if (b <= a2) b = a2 + 1;
+      let sum = 0;
+      for (let c of chs) sum += reduce(src[c], a2, b);
+      out[i] = sum / chs.length;
+    }
+    return out;
+  }
+  if (perCh) return chs.map((c) => reduce(src[c], from, to));
+  if (chs.length === 1) return reduce(src[chs[0]], from, to);
+  let vals = chs.map((c) => reduce(src[c], from, to));
+  return vals.reduce((a2, b) => a2 + b, 0) / vals.length;
+};
+
+// fn/crop.js
+function cropSegs(segs, off, len) {
+  let r = [], end = off + len;
+  for (let s of segs) {
+    let a2 = Math.max(s[2], off), b = Math.min(s[2] + s[1], end);
+    if (a2 < b) r.push(seg(s[0] + (a2 - s[2]) * Math.abs(s[3] || 1), b - a2, a2 - off, s[3], s[4]));
+  }
+  return r;
+}
+var cropPlan = (segs, ctx) => {
+  let { total, length } = ctx;
+  let s = planOffset(ctx.offset, total);
+  return cropSegs(segs, s, Math.max(0, Math.min(length ?? total - s, total - s)));
+};
+audio.op("crop", { plan: cropPlan });
+
+// fn/clip.js
+audio.fn.clip = function(opts) {
+  let inst = this.clone ? this.clone() : audio.from(this);
+  let at = parseTime(opts?.at), duration = parseTime(opts?.duration);
+  return at != null || duration != null ? inst.crop({ at: at ?? 0, duration: duration ?? Math.max(0, this.duration - (at ?? 0)) }) : inst;
+};
+
+// fn/split.js
+audio.fn.split = function(...args) {
+  let offsets = (Array.isArray(args[0]) ? args[0] : args).map(parseTime);
+  let dur = this.duration;
+  let cuts = [0, ...offsets.sort((a2, b) => a2 - b).filter((t) => t > 0 && t < dur), dur];
+  return cuts.slice(0, -1).map((start, i) => this.clip({ at: start, duration: cuts[i + 1] - start }));
+};
+
+// fn/play.js
+import Speaker from "audio-speaker";
+function ramp(buf, ch, len, fadeIn, RAMP) {
+  let n = Math.min(RAMP, len);
+  if (fadeIn) {
+    for (let i = 0; i < n; i++) {
+      let t = i / n;
+      for (let c = 0; c < ch; c++) buf[i * ch + c] *= t;
+    }
+  } else {
+    let s = len - n;
+    for (let i = 0; i < n; i++) {
+      let t = 1 - i / n;
+      for (let c = 0; c < ch; c++) buf[(s + i) * ch + c] *= t;
+    }
+  }
+}
+audio.fn.play = function(opts) {
+  let offset = opts?.at ?? 0, duration = opts?.duration;
+  let a2 = this, BLOCK = audio.BLOCK_SIZE;
+  if (a2.playing) {
+    a2.playing = false;
+    a2.paused = false;
+    if (a2._._wake) a2._._wake();
+  }
+  a2.playing = false;
+  a2.paused = opts?.paused ?? false;
+  a2.currentTime = offset;
+  if (opts?.volume != null) a2.volume = opts.volume;
+  a2.loop = opts?.loop ?? false;
+  a2.block = null;
+  a2._._wake = null;
+  a2._._seekTo = null;
+  a2.ended = false;
+  let startResolve, startReject;
+  a2.played = new Promise((r, j) => {
+    startResolve = r;
+    startReject = j;
+  });
+  a2.played.catch(() => {
+  });
+  (async () => {
+    try {
+      let ch = a2.channels, sr = a2.sampleRate;
+      a2.playing = true;
+      if (!a2.paused) emit(a2, "play");
+      let resolved2 = false;
+      let wait = async () => {
+        while (a2.paused && a2.playing && a2._._seekTo == null) await new Promise((r) => {
+          a2._._wake = r;
+        });
+        a2._._wake = null;
+      };
+      let from = offset, RAMP = 256;
+      while (a2.playing) {
+        if (a2.paused) {
+          await wait();
+          if (!a2.playing) break;
+          if (a2._._seekTo != null) {
+            from = a2._._seekTo;
+            a2._._seekTo = null;
+            a2.currentTime = from;
+            a2.seeking = false;
+          }
+        }
+        let write2 = Speaker({ sampleRate: sr, channels: ch, bitDepth: 32 });
+        let seeked = false, played = 0, fadeIn = true;
+        const flush = async () => {
+          let pad = new Uint8Array(BLOCK * ch * 4);
+          await new Promise((r) => write2(pad, r));
+          await new Promise((r) => write2(pad, r));
+        };
+        for await (let chunk of a2.stream({ at: from, duration })) {
+          if (!a2.playing) break;
+          let cLen = chunk[0].length;
+          for (let bOff = 0; bOff < cLen; bOff += BLOCK) {
+            if (a2._._seekTo != null) {
+              from = a2._._seekTo;
+              a2._._seekTo = null;
+              a2.currentTime = from;
+              a2.seeking = false;
+              seeked = true;
+              break;
+            }
+            let end = Math.min(bOff + BLOCK, cLen), len = end - bOff;
+            a2.block = chunk[0].subarray(bOff, end);
+            let g = a2.muted ? 0 : a2.volume;
+            let buf = new Float32Array(len * ch);
+            for (let i = 0; i < len; i++) for (let c = 0; c < ch; c++)
+              buf[i * ch + c] = (chunk[c] || chunk[0])[bOff + i] * g;
+            let send = () => new Promise((r) => write2(new Uint8Array(buf.buffer), r));
+            if (fadeIn) {
+              ramp(buf, ch, len, true, RAMP);
+              fadeIn = false;
+            }
+            if (a2.paused) {
+              ramp(buf, ch, len, false, RAMP);
+              await send();
+              await flush();
+              played += len;
+              a2.currentTime = from + played / sr;
+              await wait();
+              if (a2._._seekTo != null) continue;
+              if (!a2.playing) break;
+              fadeIn = true;
+              continue;
+            }
+            if (!a2.playing) {
+              ramp(buf, ch, len, false, RAMP);
+              await send();
+              break;
+            }
+            await send();
+            if (!resolved2) {
+              resolved2 = true;
+              startResolve();
+            }
+            played += len;
+            if (a2._._seekTo == null) {
+              a2.currentTime = from + played / sr;
+              emit(a2, "timeupdate", a2.currentTime);
+            }
+          }
+          if (seeked || !a2.playing) break;
+        }
+        if (!seeked && !a2.playing) await flush();
+        if (seeked) {
+          await flush();
+          fadeIn = true;
+        }
+        write2(null);
+        if (seeked) continue;
+        if (!a2.playing) break;
+        if (a2.loop) {
+          from = 0;
+          a2.currentTime = 0;
+          emit(a2, "timeupdate", 0);
+          continue;
+        }
+        a2.playing = false;
+        a2.ended = true;
+        emit(a2, "timeupdate", a2.currentTime);
+        break;
+      }
+      a2.playing = false;
+      emit(a2, "ended");
+      if (!resolved2) startResolve();
+    } catch (err) {
+      console.error("Playback error:", err);
+      a2.playing = false;
+      if (!resolved) startReject(err);
+      else emit(a2, "error", err);
+    }
+  })();
+  return this;
+};
+var proto = audio.fn;
+proto.pause = function() {
+  if (!this.paused && this.playing) {
+    this.paused = true;
+    emit(this, "pause");
+  }
+};
+proto.resume = function() {
+  if (this.paused) {
+    this._.ctStamp = performance.now();
+    this.paused = false;
+    emit(this, "play");
+    if (this._._wake) this._._wake();
+  }
+};
+
+// fn/save.js
+var FMT_ALIAS = { aif: "aiff", oga: "ogg" };
+function resolveFormat(fmt3) {
+  return FMT_ALIAS[fmt3] || fmt3 || "wav";
+}
+async function encodeStream(inst, fmt3, opts, sink) {
+  let enc = await audio_encode_default[fmt3]({ sampleRate: inst.sampleRate, channels: inst.channels, ...opts.meta });
+  let written = 0, tick = 0;
+  for await (let chunk of inst.stream({ at: opts.at, duration: opts.duration })) {
+    let buf = await enc(chunk);
+    if (buf.length) await sink(buf);
+    written += chunk[0].length;
+    if (++tick % 2 === 0) await new Promise((r) => setTimeout(r, 0));
+    emit(inst, "progress", { offset: written / inst.sampleRate, total: (opts.duration != null ? parseTime(opts.duration) : null) ?? inst.duration });
+  }
+  let final = await enc();
+  if (final.length) await sink(final);
+  return sink(null);
+}
+audio.fn.encode = async function(fmt3, opts = {}) {
+  if (typeof fmt3 === "object") {
+    opts = fmt3;
+    fmt3 = void 0;
+  }
+  fmt3 = resolveFormat(fmt3);
+  if (!audio_encode_default[fmt3]) throw new Error("Unknown format: " + fmt3);
+  let parts = [];
+  await encodeStream(this, fmt3, opts, (buf) => {
+    if (buf) parts.push(buf);
+  });
+  let total = parts.reduce((n, p) => n + p.length, 0);
+  let out = new Uint8Array(total), pos = 0;
+  for (let p of parts) {
+    out.set(p, pos);
+    pos += p.length;
+  }
+  return out;
+};
+audio.fn.save = async function(target, opts = {}) {
+  let fmt3 = opts.format ?? (typeof target === "string" ? target.split(".").pop() : "wav");
+  fmt3 = resolveFormat(fmt3);
+  if (!audio_encode_default[fmt3]) throw new Error("Unknown format: " + fmt3);
+  let write2, finish;
+  if (typeof target === "string") {
+    let { createWriteStream } = await import("fs");
+    let ws = createWriteStream(target);
+    write2 = (buf) => {
+      if (!ws.write(Buffer.from(buf))) return new Promise((r) => ws.once("drain", r));
+    };
+    finish = () => new Promise((res, rej) => {
+      ws.on("finish", res);
+      ws.on("error", rej);
+      ws.end();
+    });
+  } else if (target?.write) {
+    write2 = (buf) => target.write(buf);
+    finish = () => target.close?.();
+  } else throw new Error("Invalid save target");
+  await encodeStream(this, fmt3, opts, (buf) => buf ? write2(buf) : finish?.());
+};
+
+// fn/remove.js
+function removeSegs(segs, off, dur) {
+  let r = [], end = off + dur;
+  for (let s of segs) {
+    let se = s[2] + s[1];
+    if (se <= off) r.push(s);
+    else if (s[2] >= end) {
+      let n = s.slice();
+      n[2] = s[2] - dur;
+      r.push(n);
+    } else {
+      let absR = Math.abs(s[3] || 1);
+      if (s[2] < off) r.push(seg(s[0], off - s[2], s[2], s[3], s[4]));
+      if (se > end) r.push(seg(s[0] + (end - s[2]) * absR, se - end, off, s[3], s[4]));
+    }
+  }
+  return r;
+}
+var removePlan = (segs, ctx) => {
+  let { total } = ctx;
+  let s = planOffset(ctx.offset, total);
+  return removeSegs(segs, s, Math.min(ctx.length ?? total - s, total - s));
+};
+audio.op("remove", { plan: removePlan });
+
+// fn/insert.js
+function insertSegs(segs, at, len, ref) {
+  let r = [];
+  for (let s of segs) {
+    if (s[2] + s[1] <= at) r.push(s);
+    else if (s[2] >= at) {
+      let n = s.slice();
+      n[2] = s[2] + len;
+      r.push(n);
+    } else {
+      let f = at - s[2], absR = Math.abs(s[3] || 1);
+      r.push(seg(s[0], f, s[2], s[3], s[4]));
+      r.push(seg(s[0] + f * absR, s[1] - f, at + len, s[3], s[4]));
+    }
+  }
+  r.push(seg(0, len, at, void 0, ref ?? null));
+  r.sort((a2, b) => a2[2] - b[2]);
+  return r;
+}
+var insertPlan = (segs, ctx) => {
+  let { total, sampleRate: sr, args } = ctx;
+  let source = args[0], off = planOffset(ctx.offset, total, total);
+  if (typeof source !== "number" && !source?.pages) source = audio.from(source, { sampleRate: sr });
+  let iLen = typeof source === "number" ? Math.round(source * sr) : source.length;
+  if (ctx.length != null) iLen = Math.min(iLen, ctx.length);
+  return insertSegs(segs, off, iLen, typeof source === "number" ? null : source);
+};
+audio.op("insert", { plan: insertPlan });
+
+// fn/repeat.js
+function repeatSegs(segs, times, total, off, dur) {
+  if (off == null) {
+    let r2 = [];
+    for (let t = 0; t <= times; t++)
+      for (let s of segs) {
+        let n = s.slice();
+        n[2] = s[2] + total * t;
+        r2.push(n);
+      }
+    return r2;
+  }
+  let segLen = dur ?? total - off, clip = cropSegs(segs, off, segLen), r = [];
+  for (let s of segs) {
+    let se = s[2] + s[1];
+    if (se <= off + segLen) r.push(s);
+    else if (s[2] >= off + segLen) {
+      let n = s.slice();
+      n[2] = s[2] + segLen * times;
+      r.push(n);
+    } else {
+      let absR = Math.abs(s[3] || 1), split = off + segLen - s[2];
+      r.push(seg(s[0], split, s[2], s[3], s[4]));
+      r.push(seg(s[0] + split * absR, se - off - segLen, off + segLen * (times + 1), s[3], s[4]));
+    }
+  }
+  for (let t = 1; t <= times; t++)
+    for (let c of clip) {
+      let n = c.slice();
+      n[2] = off + segLen * t + c[2];
+      r.push(n);
+    }
+  r.sort((a2, b) => a2[2] - b[2]);
+  return r;
+}
+var repeatPlan = (segs, ctx) => {
+  let { total, args, length } = ctx;
+  let off = ctx.offset != null ? planOffset(ctx.offset, total) : null;
+  return repeatSegs(segs, args[0] ?? 1, total, off, length);
+};
+audio.op("repeat", { plan: repeatPlan });
+
+// fn/gain.js
+var gain = (chs, ctx) => {
+  let lin = ctx.unit === "linear", val = ctx.args[0] ?? (lin ? 1 : 0);
+  let [s, end] = opRange(ctx, chs[0].length);
+  let auto = typeof val === "function", f = auto ? 0 : lin ? val : 10 ** (val / 20);
+  let off = (ctx.blockOffset || 0) * ctx.sampleRate;
+  let toMul = lin ? (v) => v : (v) => 10 ** (v / 20);
+  for (let ch of chs)
+    for (let i = Math.max(0, s); i < Math.min(end, ch.length); i++)
+      ch[i] *= auto ? toMul(val((off + i) / ctx.sampleRate)) : f;
+  return chs;
+};
+audio.op("gain", { process: gain });
+
+// fn/fade.js
+var CURVES = {
+  linear: (t) => t,
+  exp: (t) => t * t,
+  log: (t) => Math.sqrt(t),
+  cos: (t) => (1 - Math.cos(t * Math.PI)) / 2
+};
+var fade = (chs, ctx) => {
+  let dur = ctx.args[0];
+  let fn3 = CURVES[ctx.curve] ?? CURVES.linear;
+  let fadeIn = dur > 0, n = Math.abs(dur);
+  let sr = ctx.sampleRate, blockOffset = ctx.blockOffset || 0;
+  let at = ctx.at != null ? ctx.at + blockOffset : void 0;
+  if (at != null && at < 0) at = ctx.totalDuration + at;
+  let totalSamples = Math.round((ctx.totalDuration || chs[0].length / sr + blockOffset) * sr);
+  let fadeStart = at != null ? Math.round(at * sr) : fadeIn ? 0 : totalSamples - Math.round(n * sr);
+  let samples = Math.round(n * sr);
+  let chunkStart = Math.round(blockOffset * sr);
+  for (let ch of chs)
+    for (let i = 0; i < ch.length; i++) {
+      let fi = chunkStart + i - fadeStart;
+      if (fi < 0 || fi >= samples) continue;
+      ch[i] *= fn3(fadeIn ? fi / samples : 1 - fi / samples);
+    }
+  return chs;
+};
+audio.op("fade", {
+  process: fade,
+  call(std, ...a2) {
+    let last = a2[a2.length - 1];
+    let opts = typeof last === "object" ? a2.pop() : typeof last === "string" ? { curve: a2.pop() } : null;
+    if (typeof a2[a2.length - 1] === "string") opts = { ...opts, curve: a2.pop() };
+    let [inDur, outDur] = a2;
+    if (outDur != null) {
+      std.call(this, Math.abs(inDur), opts || {});
+      return std.call(this, -Math.abs(outDur), opts || {});
+    }
+    return opts ? std.call(this, inDur, opts) : std.call(this, inDur);
+  }
+});
+
+// fn/reverse.js
+function reverseSegs(segs, off, end) {
+  let r = [];
+  for (let s of segs) {
+    let se = s[2] + s[1];
+    if (se <= off || s[2] >= end) {
+      r.push(s);
+      continue;
+    }
+    let absR = Math.abs(s[3] || 1);
+    if (s[2] < off) r.push(seg(s[0], off - s[2], s[2], s[3], s[4]));
+    let iStart = Math.max(s[2], off), iEnd = Math.min(se, end);
+    r.push(seg(s[0] + (iStart - s[2]) * absR, iEnd - iStart, off + end - iEnd, -(s[3] || 1), s[4]));
+    if (se > end) r.push(seg(s[0] + (end - s[2]) * absR, se - end, end, s[3], s[4]));
+  }
+  r.sort((a2, b) => a2[2] - b[2]);
+  return r;
+}
+var reversePlan = (segs, ctx) => {
+  let { total, length } = ctx;
+  let s = planOffset(ctx.offset, total);
+  return reverseSegs(segs, s, s + (length ?? total - s));
+};
+audio.op("reverse", { plan: reversePlan });
+
+// fn/mix.js
+var mix = (chs, ctx) => {
+  let source = ctx.args[0], sr = ctx.sampleRate, chLen = chs[0].length;
+  if (typeof source === "number") throw new TypeError("mix: expected audio instance or Float32Array[], not a number");
+  let sLen = Array.isArray(source) ? source[0].length : source.length;
+  let [s] = opRange(ctx, chLen);
+  let srcOff = Math.max(0, -s), dstOff = Math.max(0, s);
+  let n = Math.min(sLen - srcOff, chLen - dstOff);
+  if (ctx.duration != null) n = Math.min(n, Math.round(ctx.duration * sr) - srcOff);
+  if (n <= 0) return chs;
+  let src = ctx.render(source, srcOff, n);
+  for (let c = 0; c < chs.length; c++) {
+    let m2 = src[c % src.length];
+    for (let i = 0; i < n; i++) chs[c][dstOff + i] += m2[i];
+  }
+  return chs;
+};
+audio.op("mix", { process: mix });
+
+// fn/write.js
+var write = (chs, ctx) => {
+  let data = ctx.args[0];
+  let [p, end] = opRange(ctx, chs[0].length);
+  let srcOff = Math.max(0, -p), dstOff = Math.max(0, p);
+  for (let c = 0; c < chs.length; c++) {
+    let s = Array.isArray(data) ? data[c] || data[0] : data;
+    for (let i = srcOff; i < s.length && dstOff + i - srcOff < end; i++) chs[c][dstOff + i - srcOff] = s[i];
+  }
+  return chs;
+};
+audio.op("write", { process: write });
+
+// fn/remix.js
+var remix = (chs, ctx) => {
+  let arg = ctx.args[0], len = chs[0].length;
+  if (Array.isArray(arg)) {
+    return arg.map(
+      (src) => src == null ? new Float32Array(len) : new Float32Array(chs[(src % chs.length + chs.length) % chs.length])
+    );
+  }
+  let n = chs.length, m2 = arg;
+  if (n === m2) return false;
+  if (m2 < n) {
+    let out = new Float32Array(len);
+    for (let c = 0; c < n; c++)
+      for (let i = 0; i < len; i++) out[i] += chs[c][i];
+    let inv = 1 / n;
+    for (let i = 0; i < len; i++) out[i] *= inv;
+    return Array.from({ length: m2 }, () => new Float32Array(out));
+  }
+  return Array.from({ length: m2 }, (_, c) => new Float32Array(chs[c % n]));
+};
+var remixCh = (_, args) => Array.isArray(args[0]) ? args[0].length : args[0];
+audio.op("remix", { process: remix, ch: remixCh });
+
+// fn/trim.js
+function autoThreshold(energies) {
+  let vals = energies.filter((e) => e > 0);
+  if (!vals.length) return -40;
+  vals.sort((a2, b) => a2 - b);
+  let floor = vals[Math.floor(vals.length * 0.1)];
+  return Math.max(-80, Math.min(-20, 10 * Math.log10(floor) + 12));
+}
+function resolveThreshold(stats, ch, from, to, db) {
+  if (db == null) {
+    let energies = [];
+    for (let c = 0; c < ch; c++) for (let i = from; i < to; i++) energies.push(stats.energy[c][i]);
+    db = autoThreshold(energies);
+  }
+  return 10 ** (db / 20);
+}
+var isLoud = (stats, i, ch, thresh) => {
+  for (let c = 0; c < ch; c++)
+    if (Math.max(Math.abs(stats.min[c][i]), Math.abs(stats.max[c][i])) > thresh) return true;
+  return false;
+};
+var trim = (chs, ctx) => {
+  let threshold = ctx.args[0];
+  if (threshold == null) {
+    let energies = [];
+    for (let c = 0; c < chs.length; c++)
+      for (let off = 0; off < chs[c].length; off += audio.BLOCK_SIZE) {
+        let end = Math.min(off + audio.BLOCK_SIZE, chs[c].length), sum = 0;
+        for (let i = off; i < end; i++) sum += chs[c][i] * chs[c][i];
+        energies.push(sum / (end - off));
+      }
+    threshold = autoThreshold(energies);
+  }
+  let thresh = 10 ** (threshold / 20);
+  let len = chs[0].length, s = 0, e = len - 1;
+  for (; s < len; s++) {
+    let loud = false;
+    for (let c = 0; c < chs.length; c++) if (Math.abs(chs[c][s]) > thresh) {
+      loud = true;
+      break;
+    }
+    ;
+    if (loud) break;
+  }
+  for (; e >= s; e--) {
+    let loud = false;
+    for (let c = 0; c < chs.length; c++) if (Math.abs(chs[c][e]) > thresh) {
+      loud = true;
+      break;
+    }
+    ;
+    if (loud) break;
+  }
+  e++;
+  return s === 0 && e === len ? false : chs.map((ch) => ch.slice(s, e));
+};
+var trimResolve = (args, { stats, sampleRate: sampleRate2, totalDuration }) => {
+  if (!stats?.min || !stats?.energy) return null;
+  let ch = stats.min.length, blocks = stats.min[0].length;
+  let total = Math.round(totalDuration * sampleRate2);
+  let thresh = resolveThreshold(stats, ch, 0, stats.energy[0].length, args[0]);
+  let s = 0, e = blocks - 1;
+  for (; s < blocks; s++) if (isLoud(stats, s, ch, thresh)) break;
+  for (; e >= s; e--) if (isLoud(stats, e, ch, thresh)) break;
+  e++;
+  if (s === 0 && e === blocks) return false;
+  if (s >= e) return { type: "crop", args: [], at: 0, duration: 0 };
+  let startSample = s * audio.BLOCK_SIZE;
+  let endSample = Math.min(e * audio.BLOCK_SIZE, total);
+  return { type: "crop", args: [], at: startSample / sampleRate2, duration: (endSample - startSample) / sampleRate2 };
+};
+audio.op("trim", { process: trim, resolve: trimResolve });
+
+// node_modules/digital-filter/core/filter.js
+function filter(data, params) {
+  let coefs2 = params.coefs;
+  if (!Array.isArray(coefs2)) coefs2 = [coefs2];
+  let n = coefs2.length;
+  if (!params.state) {
+    params.state = new Array(n);
+    for (let i = 0; i < n; i++) params.state[i] = [0, 0];
+  }
+  let state = params.state;
+  for (let i = 0, l = data.length; i < l; i++) {
+    let x = data[i];
+    for (let j = 0; j < n; j++) {
+      let c = coefs2[j], s = state[j];
+      let y2 = c.b0 * x + s[0];
+      s[0] = c.b1 * x - c.a1 * y2 + s[1];
+      s[1] = c.b2 * x - c.a2 * y2;
+      x = y2;
+    }
+    data[i] = x;
+  }
+  return data;
+}
+
+// node_modules/digital-filter/iir/biquad.js
+var { sin, cos, sqrt, pow, PI } = Math;
+var SILENCE = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 };
+var PASS = { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 };
+var gain2 = (A2) => ({ b0: A2, b1: 0, b2: 0, a1: 0, a2: 0 });
+function norm3(b0, b1, b2, a0, a1, a2) {
+  return { b0: b0 / a0, b1: b1 / a0, b2: b2 / a0, a1: a1 / a0, a2: a2 / a0 };
+}
+function intermediates(fc, Q, fs) {
+  let w0 = 2 * PI * fc / fs;
+  let sinw = sin(w0), cosw = cos(w0);
+  let alpha = sinw / (2 * Q);
+  return { sinw, cosw, alpha };
+}
+function lowpass(fc, Q, fs) {
+  if (fc <= 0) return SILENCE;
+  if (fc >= fs / 2) return PASS;
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  return norm3(
+    (1 - cosw) / 2,
+    1 - cosw,
+    (1 - cosw) / 2,
+    1 + alpha,
+    -2 * cosw,
+    1 - alpha
+  );
+}
+function highpass(fc, Q, fs) {
+  if (fc <= 0) return PASS;
+  if (fc >= fs / 2) return SILENCE;
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  return norm3(
+    (1 + cosw) / 2,
+    -(1 + cosw),
+    (1 + cosw) / 2,
+    1 + alpha,
+    -2 * cosw,
+    1 - alpha
+  );
+}
+function bandpass(fc, Q, fs) {
+  if (fc <= 0 || fc >= fs / 2) return SILENCE;
+  if (Q <= 0) return SILENCE;
+  let { sinw, cosw, alpha } = intermediates(fc, Q, fs);
+  return norm3(
+    sinw / 2,
+    0,
+    -sinw / 2,
+    1 + alpha,
+    -2 * cosw,
+    1 - alpha
+  );
+}
+function notch(fc, Q, fs) {
+  if (fc <= 0 || fc >= fs / 2) return PASS;
+  if (Q <= 0) return SILENCE;
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  return norm3(
+    1,
+    -2 * cosw,
+    1,
+    1 + alpha,
+    -2 * cosw,
+    1 - alpha
+  );
+}
+function peaking(fc, Q, fs, dBgain) {
+  if (fc <= 0 || fc >= fs / 2) return PASS;
+  if (Q <= 0) return gain2(pow(10, dBgain / 20));
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  let A = pow(10, dBgain / 40);
+  return norm3(
+    1 + alpha * A,
+    -2 * cosw,
+    1 - alpha * A,
+    1 + alpha / A,
+    -2 * cosw,
+    1 - alpha / A
+  );
+}
+function lowshelf(fc, Q, fs, dBgain) {
+  let A = pow(10, dBgain / 40);
+  if (fc <= 0) return PASS;
+  if (fc >= fs / 2) return gain2(A * A);
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  let s = 2 * sqrt(A) * alpha;
+  return norm3(
+    A * (A + 1 - (A - 1) * cosw + s),
+    2 * A * (A - 1 - (A + 1) * cosw),
+    A * (A + 1 - (A - 1) * cosw - s),
+    A + 1 + (A - 1) * cosw + s,
+    -2 * (A - 1 + (A + 1) * cosw),
+    A + 1 + (A - 1) * cosw - s
+  );
+}
+function highshelf(fc, Q, fs, dBgain) {
+  let A = pow(10, dBgain / 40);
+  if (fc <= 0) return gain2(A * A);
+  if (fc >= fs / 2) return PASS;
+  let { cosw, alpha } = intermediates(fc, Q, fs);
+  let s = 2 * sqrt(A) * alpha;
+  return norm3(
+    A * (A + 1 + (A - 1) * cosw + s),
+    -2 * A * (A - 1 + (A + 1) * cosw),
+    A * (A + 1 + (A - 1) * cosw - s),
+    A + 1 - (A - 1) * cosw + s,
+    2 * (A - 1 - (A + 1) * cosw),
+    A + 1 - (A - 1) * cosw - s
+  );
+}
+
+// node_modules/audio-filter/weighting/k-weighting.js
+function kWeighting(data, params = {}) {
+  let fs = params.fs || 48e3;
+  if (!params._sos || params._fs !== fs) {
+    params._fs = fs;
+    params._sos = kWeighting.coefs(fs);
+  }
+  if (!params.state) params.state = params._sos.map(() => [0, 0]);
+  return filter(data, { coefs: params._sos, state: params.state });
+}
+kWeighting.coefs = function coefs(fs = 48e3) {
+  if (fs === 48e3) return [
+    { b0: 1.53512485958697, b1: -2.69169618940638, b2: 1.19839281085285, a1: -1.69065929318241, a2: 0.73248077421585 },
+    { b0: 1, b1: -2, b2: 1, a1: -1.99004745483398, a2: 0.99007225036621 }
+  ];
+  return [
+    highshelf(1681, 0.7072, fs, 3.9997),
+    highpass(38, 0.7072, fs)
+  ];
+};
+
+// fn/loudness.js
+var GATE_WINDOW = 0.4;
+var ABS_GATE = -70;
+var REL_GATE = -10;
+var LUFS_OFFSET = -0.691;
+function lufsFromEnergy(energy, chs, sampleRate2, blockSize, from = 0, to) {
+  if (to == null) to = energy[0].length;
+  if (typeof chs === "number") chs = Array.from({ length: chs }, (_, i) => i);
+  let winBlocks = Math.ceil(GATE_WINDOW * sampleRate2 / blockSize), gates = [];
+  for (let i = from; i < to; i += winBlocks) {
+    let we = Math.min(i + winBlocks, to), sum = 0, n = 0;
+    for (let c of chs) for (let j = i; j < we; j++) {
+      sum += energy[c][j];
+      n++;
+    }
+    if (n > 0) gates.push(sum / n);
+  }
+  let absT = 10 ** (ABS_GATE / 10), gated = gates.filter((g) => g > absT);
+  if (!gated.length) return null;
+  let mean = gated.reduce((a2, b) => a2 + b, 0) / gated.length;
+  let final = gated.filter((g) => g > mean * 10 ** (REL_GATE / 10));
+  if (!final.length) return null;
+  return LUFS_OFFSET + 10 * Math.log10(final.reduce((a2, b) => a2 + b, 0) / final.length);
+}
+function dcOffsets(stats, chs) {
+  let off = new Float64Array(stats.dc.length);
+  for (let c of chs) {
+    let n = stats.dc[c].length;
+    if (!n) {
+      off[c] = 0;
+      continue;
+    }
+    let sum = 0;
+    for (let i = 0; i < n; i++) sum += stats.dc[c][i];
+    off[c] = sum / n;
+  }
+  return off;
+}
+function peakDb(stats, chs, dcOff) {
+  let peak = 0;
+  for (let c of chs) {
+    let d2 = dcOff?.[c] || 0;
+    for (let i = 0; i < stats.min[c].length; i++)
+      peak = Math.max(peak, Math.abs(stats.min[c][i] - d2), Math.abs(stats.max[c][i] - d2));
+  }
+  return peak ? 20 * Math.log10(peak) : null;
+}
+function rmsDb(stats, chs, dcOff) {
+  if (!stats.rms) return null;
+  let totalE = 0, n = 0;
+  for (let c of chs) {
+    let d2 = dcOff?.[c] || 0;
+    for (let i = 0; i < stats.rms[c].length; i++) {
+      totalE += stats.rms[c][i] - d2 * d2;
+      n++;
+    }
+  }
+  return n && totalE > 0 ? 10 * Math.log10(totalE / n) : null;
+}
+function lufsDb(stats, chs, sampleRate2) {
+  return lufsFromEnergy(stats.energy, chs, sampleRate2, stats.blockSize) ?? null;
+}
+var rMean = (src, from, to) => {
+  let n = to - from;
+  if (!n) return 0;
+  let v = 0;
+  for (let i = from; i < to; i++) v += src[i];
+  return v / n;
+};
+audio.stat("energy", {
+  block: (chs, ctx) => {
+    if (!ctx.k) ctx.k = chs.map(() => ({ fs: ctx.sampleRate }));
+    return chs.map((ch, c) => {
+      let k = new Float32Array(ch);
+      kWeighting(k, ctx.k[c]);
+      let sum = 0;
+      for (let i = 0; i < k.length; i++) sum += k[i] * k[i];
+      return sum / k.length;
+    });
+  },
+  reduce: rMean
+});
+audio.stat("db", {
+  query: (stats, chs, from, to) => {
+    let peak = 0;
+    for (let c of chs)
+      for (let i = from; i < Math.min(to, stats.min[c].length); i++)
+        peak = Math.max(peak, Math.abs(stats.min[c][i]), Math.abs(stats.max[c][i]));
+    return peak > 0 ? 20 * Math.log10(peak) : -Infinity;
+  }
+});
+audio.stat("loudness", {
+  query: (stats, chs, from, to, sr) => {
+    let v = lufsFromEnergy(stats.energy, chs, sr, stats.blockSize, from, to);
+    return v ?? -Infinity;
+  }
+});
+
+// fn/normalize.js
+var PRESETS = { streaming: -14, podcast: -16, broadcast: -23 };
+audio.op("dc", {
+  hidden: true,
+  process: (chs, ctx) => {
+    let offsets = ctx.args[0];
+    if (typeof offsets === "number") offsets = [offsets];
+    for (let c = 0; c < chs.length; c++) {
+      let d2 = offsets[c % offsets.length] || 0;
+      if (Math.abs(d2) < 1e-10) continue;
+      for (let i = 0; i < chs[c].length; i++) chs[c][i] -= d2;
+    }
+    return chs;
+  }
+});
+audio.op("clamp", {
+  hidden: true,
+  process: (chs, ctx) => {
+    let limit = ctx.args[0];
+    for (let c = 0; c < chs.length; c++)
+      for (let i = 0; i < chs[c].length; i++)
+        chs[c][i] = Math.max(-limit, Math.min(limit, chs[c][i]));
+    return chs;
+  }
+});
+audio.op("normalize", {
+  process: () => false,
+  resolve: (args, ctx) => {
+    let { stats, sampleRate: sampleRate2 } = ctx;
+    if (!stats?.min) return null;
+    let arg = args[0];
+    let mode = typeof arg === "string" ? "lufs" : ctx.mode || "peak";
+    let targetDb = PRESETS[arg] ?? (typeof arg === "number" ? arg : ctx.target ?? 0);
+    let totalCh = stats.min.length;
+    let chs = ctx.channel != null ? Array.isArray(ctx.channel) ? ctx.channel : [ctx.channel] : Array.from({ length: totalCh }, (_, i) => i);
+    let dcOff = new Float64Array(totalCh);
+    if (ctx.dc !== false && stats.dc) dcOff = dcOffsets(stats, chs);
+    let hasDc = chs.some((c) => Math.abs(dcOff[c]) > 1e-10);
+    let levelDb;
+    if (mode === "lufs") levelDb = lufsDb(stats, chs, sampleRate2);
+    else if (mode === "rms") levelDb = rmsDb(stats, chs, dcOff);
+    else levelDb = peakDb(stats, chs, dcOff);
+    if (levelDb == null) return false;
+    let edits = [];
+    if (hasDc) edits.push({ type: "dc", args: [chs.map((c) => dcOff[c])] });
+    if (ctx.ceiling != null) {
+      let peakLevel = peakDb(stats, chs, dcOff);
+      if (peakLevel == null) return false;
+      edits.push({ type: "gain", args: [targetDb - peakLevel] });
+      edits.push({ type: "clamp", args: [10 ** (ctx.ceiling / 20)] });
+    } else {
+      edits.push({ type: "gain", args: [targetDb - levelDb] });
+    }
+    return edits.length === 1 ? edits[0] : edits;
+  },
+  call(std, arg) {
+    if (typeof arg === "string" || typeof arg === "number") return std.call(this, arg);
+    if (arg != null && typeof arg === "object") {
+      let { target, mode, at, duration, channel, ...extra } = arg;
+      return std.call(this, target, { mode, at, duration, channel, ...extra });
+    }
+    return std.call(this);
+  }
+});
+
+// node_modules/audio-filter/effect/highpass.js
+var butterworth;
+function highpass2(data, params) {
+  let fc = params.fc, fs = params.fs || 44100;
+  let order = params.order || 2, Q = params.Q == null ? 0.707 : params.Q;
+  if (!params.coefs || params._fc !== fc || params._order !== order || params._Q !== Q || params._fs !== fs) {
+    if (order <= 2) params.coefs = [highpass(fc, Q, fs)];
+    else {
+      if (!butterworth) throw new Error("Import digital-filter/iir/butterworth.js for order > 2");
+      params.coefs = butterworth(order, fc, fs, "highpass");
+    }
+    params._fc = fc;
+    params._order = order;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params);
+}
+highpass2.useButterworth = (bw) => {
+  butterworth = bw;
+};
+
+// node_modules/audio-filter/effect/lowpass.js
+var butterworth2;
+function lowpass2(data, params) {
+  let fc = params.fc, fs = params.fs || 44100;
+  let order = params.order || 2, Q = params.Q == null ? 0.707 : params.Q;
+  if (!params.coefs || params._fc !== fc || params._order !== order || params._Q !== Q || params._fs !== fs) {
+    if (order <= 2) params.coefs = [lowpass(fc, Q, fs)];
+    else {
+      if (!butterworth2) throw new Error("Import digital-filter/iir/butterworth.js for order > 2");
+      params.coefs = butterworth2(order, fc, fs, "lowpass");
+    }
+    params._fc = fc;
+    params._order = order;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params);
+}
+lowpass2.useButterworth = (bw) => {
+  butterworth2 = bw;
+};
+
+// node_modules/audio-filter/effect/bandpass.js
+function bandpass2(data, params) {
+  let fc = params.fc, Q = params.Q == null ? 0.707 : params.Q, fs = params.fs || 44100;
+  if (!params.coefs || params._fc !== fc || params._Q !== Q || params._fs !== fs) {
+    params.coefs = [bandpass(fc, Q, fs)];
+    params._fc = fc;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params);
+}
+
+// node_modules/audio-filter/effect/notch.js
+function notch2(data, params) {
+  let fc = params.fc, Q = params.Q == null ? 30 : params.Q, fs = params.fs || 44100;
+  if (!params.coefs || params._fc !== fc || params._Q !== Q || params._fs !== fs) {
+    params.coefs = [notch(fc, Q, fs)];
+    params._fc = fc;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params);
+}
+
+// node_modules/audio-filter/eq/lowshelf.js
+function lowShelf(data, params) {
+  let fc = params.fc || 200, gain3 = params.gain || 0;
+  let Q = params.Q == null ? 0.707 : params.Q, fs = params.fs || 44100;
+  if (!params._lo || params._fc !== fc || params._gain !== gain3 || params._Q !== Q || params._fs !== fs) {
+    params._lo = { coefs: [lowshelf(fc, Q, fs, gain3)] };
+    params._fc = fc;
+    params._gain = gain3;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params._lo);
+}
+
+// node_modules/audio-filter/eq/highshelf.js
+function highShelf(data, params) {
+  let fc = params.fc || 4e3, gain3 = params.gain || 0;
+  let Q = params.Q == null ? 0.707 : params.Q, fs = params.fs || 44100;
+  if (!params._hi || params._fc !== fc || params._gain !== gain3 || params._Q !== Q || params._fs !== fs) {
+    params._hi = { coefs: [highshelf(fc, Q, fs, gain3)] };
+    params._fc = fc;
+    params._gain = gain3;
+    params._Q = Q;
+    params._fs = fs;
+  }
+  return filter(data, params._hi);
+}
+
+// node_modules/audio-filter/eq/parametric-eq.js
+function parametricEq(data, params) {
+  let fs = params.fs || 44100;
+  let bands = params.bands || [];
+  if (!params._filters || params._dirty) {
+    params._filters = bands.map((b) => {
+      let fn3 = b.type === "lowshelf" ? lowshelf : b.type === "highshelf" ? highshelf : peaking;
+      return { coefs: fn3(b.fc, b.Q || 1, fs, b.gain || 0) };
+    });
+    params._dirty = false;
+  }
+  for (let f of params._filters) filter(data, f);
+  return data;
+}
+
+// fn/filter.js
+function apply(chs, ctx, key, fn3, makeParams) {
+  if (!ctx[key]) ctx[key] = chs.map(() => makeParams(ctx.sampleRate));
+  let st = ctx[key];
+  for (let c = 0; c < chs.length; c++) fn3(chs[c], st[c]);
+  return chs;
+}
+var types = {
+  highpass: (chs, ctx, args) => apply(chs, ctx, "_hp", highpass2, (fs) => ({ fc: args[0], fs })),
+  lowpass: (chs, ctx, args) => apply(chs, ctx, "_lp", lowpass2, (fs) => ({ fc: args[0], fs })),
+  eq: (chs, ctx, args) => apply(chs, ctx, "_eq", parametricEq, (fs) => ({ bands: [{ fc: args[0], Q: args[2] ?? 1, gain: args[1] ?? 0, type: "peak" }], fs })),
+  lowshelf: (chs, ctx, args) => apply(chs, ctx, "_ls", lowShelf, (fs) => ({ fc: args[0], gain: args[1] ?? 0, Q: args[2] ?? 0.707, fs })),
+  highshelf: (chs, ctx, args) => apply(chs, ctx, "_hs", highShelf, (fs) => ({ fc: args[0], gain: args[1] ?? 0, Q: args[2] ?? 0.707, fs })),
+  notch: (chs, ctx, args) => apply(chs, ctx, "_notch", notch2, (fs) => ({ fc: args[0], Q: args[1] ?? 30, fs })),
+  bandpass: (chs, ctx, args) => apply(chs, ctx, "_bp", bandpass2, (fs) => ({ fc: args[0], Q: args[1] ?? 0.707, fs }))
+};
+var filter2 = (chs, ctx) => {
+  let [type, ...args] = ctx.args;
+  if (typeof type === "function") {
+    let opts = args[0] || {};
+    return apply(chs, ctx, "_custom", type, (fs) => ({ ...opts, fs }));
+  }
+  let fn3 = types[type];
+  if (!fn3) throw new Error(`Unknown filter type: ${type}`);
+  return fn3(chs, ctx, args);
+};
+audio.op("filter", {
+  process: filter2,
+  call(std, type, ...args) {
+    if (typeof type === "function") {
+      let opts = args[0] || {};
+      let { at, duration, channel, offset, length, ...rest } = opts;
+      let edit = { type: "filter", args: [type, rest] };
+      if (at != null) edit.at = at;
+      if (duration != null) edit.duration = duration;
+      if (channel != null) edit.channel = channel;
+      if (offset != null) edit.offset = offset;
+      if (length != null) edit.length = length;
+      return this.run(edit);
+    }
+    return std.call(this, type, ...args);
+  }
+});
+for (let name in types) {
+  audio.op(name, { process: (chs, ctx) => types[name](chs, ctx, ctx.args) });
+}
+
+// fn/pan.js
+var pan = (chs, ctx) => {
+  let val = ctx.args[0] ?? 0;
+  if (chs.length < 2) return false;
+  let auto = typeof val === "function";
+  let [s, end] = opRange(ctx, chs[0].length);
+  let off = (ctx.blockOffset || 0) * ctx.sampleRate;
+  if (!auto) {
+    val = Math.max(-1, Math.min(1, val));
+    let gL = val <= 0 ? 1 : 1 - val, gR = val >= 0 ? 1 : 1 + val, gains = [gL, gR];
+    for (let c = 0; c < chs.length; c++) {
+      let g = gains[c] ?? 1;
+      if (g === 1) continue;
+      for (let i = Math.max(0, s); i < Math.min(end, chs[c].length); i++) chs[c][i] *= g;
+    }
+    return chs;
+  }
+  let L = chs[0], R = chs[1];
+  for (let i = Math.max(0, s); i < Math.min(end, L.length); i++) {
+    let p = Math.max(-1, Math.min(1, val((off + i) / ctx.sampleRate)));
+    L[i] *= p <= 0 ? 1 : 1 - p;
+    R[i] *= p >= 0 ? 1 : 1 + p;
+  }
+  return chs;
+};
+audio.op("pan", { process: pan });
+
+// fn/pad.js
+var padPlan = (segs, ctx) => {
+  let { total, sampleRate: sr, args } = ctx;
+  let before = args[0] ?? 0, after = args.length > 1 ? args[1] : before;
+  let bN = Math.round(before * sr), aN = Math.round(after * sr);
+  let r = segs.map((s) => {
+    let n = s.slice();
+    n[2] = s[2] + bN;
+    return n;
+  });
+  if (bN > 0) r.unshift(seg(0, bN, 0, void 0, null));
+  if (aN > 0) r.push(seg(0, aN, total + bN, void 0, null));
+  return r;
+};
+audio.op("pad", { plan: padPlan });
+
+// fn/speed.js
+var speedPlan = (segs, ctx) => {
+  let rate = ctx.args[0];
+  if (rate === 0) throw new RangeError("speed: rate cannot be 0");
+  if (!rate || rate === 1) return segs;
+  let absR = Math.abs(rate);
+  let r = [], dst = 0;
+  for (let s of segs) {
+    let count = Math.round(s[1] / absR);
+    r.push(seg(s[0], count, dst, s[4] === null ? s[3] : (s[3] || 1) * rate, s[4]));
+    dst += count;
+  }
+  return r;
+};
+audio.op("speed", { plan: speedPlan });
+
+// fn/transform.js
+audio.op("transform", {
+  process: (chs, ctx) => ctx.args[0](chs, ctx),
+  call(std, f) {
+    return this.run({ type: "transform", args: [f] });
+  }
+});
+
+// fn/stat.js
+var rMin = (src, from, to) => {
+  let v = Infinity;
+  for (let i = from; i < to; i++) if (src[i] < v) v = src[i];
+  return v === Infinity ? 0 : v;
+};
+var rMax = (src, from, to) => {
+  let v = -Infinity;
+  for (let i = from; i < to; i++) if (src[i] > v) v = src[i];
+  return v === -Infinity ? 0 : v;
+};
+var rSum = (src, from, to) => {
+  let v = 0;
+  for (let i = from; i < to; i++) v += src[i];
+  return v;
+};
+var rMean2 = (src, from, to) => {
+  let n = to - from;
+  if (!n) return 0;
+  let v = 0;
+  for (let i = from; i < to; i++) v += src[i];
+  return v / n;
+};
+var rRms = (src, from, to) => {
+  let n = to - from;
+  if (!n) return 0;
+  let v = 0;
+  for (let i = from; i < to; i++) v += src[i];
+  return Math.sqrt(v / n);
+};
+audio.stat("min", {
+  block: (chs) => chs.map((ch) => {
+    let mn = Infinity;
+    for (let i = 0; i < ch.length; i++) if (ch[i] < mn) mn = ch[i];
+    return mn;
+  }),
+  reduce: rMin,
+  query: (stats, chs, from, to) => {
+    let v = Infinity;
+    for (let c of chs) for (let i = from; i < Math.min(to, stats.min[c].length); i++) if (stats.min[c][i] < v) v = stats.min[c][i];
+    return v === Infinity ? 0 : v;
+  }
+});
+audio.stat("max", {
+  block: (chs) => chs.map((ch) => {
+    let mx = -Infinity;
+    for (let i = 0; i < ch.length; i++) if (ch[i] > mx) mx = ch[i];
+    return mx;
+  }),
+  reduce: rMax,
+  query: (stats, chs, from, to) => {
+    let v = -Infinity;
+    for (let c of chs) for (let i = from; i < Math.min(to, stats.max[c].length); i++) if (stats.max[c][i] > v) v = stats.max[c][i];
+    return v === -Infinity ? 0 : v;
+  }
+});
+audio.stat("dc", {
+  block: (chs) => chs.map((ch) => {
+    let sum = 0;
+    for (let i = 0; i < ch.length; i++) sum += ch[i];
+    return sum / ch.length;
+  }),
+  reduce: rMean2
+});
+audio.stat("clipping", {
+  block: (chs) => chs.map((ch) => {
+    let n = 0;
+    for (let i = 0; i < ch.length; i++) if (ch[i] >= 1 || ch[i] <= -1) n++;
+    return n;
+  }),
+  reduce: rSum,
+  query: (stats, chs, from, to, sr) => {
+    let bs = stats.blockSize, times = [];
+    for (let i = from; i < to; i++) {
+      let n = 0;
+      for (let c of chs) n += stats.clipping[c][i] || 0;
+      if (n > 0) times.push(i * bs / sr);
+    }
+    return new Float32Array(times);
+  }
+});
+audio.stat("rms", {
+  block: (chs) => chs.map((ch) => {
+    let sum = 0;
+    for (let i = 0; i < ch.length; i++) sum += ch[i] * ch[i];
+    return sum / ch.length;
+  }),
+  reduce: rRms,
+  query: (stats, chs, from, to) => {
+    let sum = 0, n = 0;
+    for (let c of chs)
+      for (let i = from; i < Math.min(to, stats.rms[c].length); i++) {
+        sum += stats.rms[c][i];
+        n++;
+      }
+    return n ? Math.sqrt(sum / n) : 0;
+  }
+});
+
+// node_modules/fourier-transform/index.js
+var { sqrt: sqrt2, sin: sin2, cos: cos2, abs, SQRT1_2, SQRT2 } = Math;
+var TWO_PI = 6.283185307179586;
+var cache = /* @__PURE__ */ new Map();
+var lastN = 0;
+var lastEntry = null;
+function init(N) {
+  const half = N >>> 1;
+  const x = new Float64Array(N);
+  const spectrum = new Float64Array(half);
+  const im = new Float64Array(half + 1);
+  const re = x.subarray(0, half + 1);
+  const complex = [re, im];
+  const bSi = 2 / N;
+  const bits = 31 - Math.clz32(N);
+  const perm = new Uint32Array(N);
+  for (let i = 0; i < N; i++) {
+    let rev = 0, v = i;
+    for (let j = 0; j < bits; j++) {
+      rev = rev << 1 | v & 1;
+      v >>= 1;
+    }
+    perm[i] = rev;
+  }
+  let total = 0, n2 = 2, nn = half;
+  const stages = [];
+  while (nn = nn >>> 1) {
+    n2 = n2 << 1;
+    const n8 = n2 >>> 3;
+    const count = n8 > 1 ? n8 - 1 : 0;
+    stages.push({ offset: total, count });
+    total += count;
+  }
+  const tw = new Float64Array(total << 2);
+  n2 = 2;
+  nn = half;
+  let si = 0;
+  while (nn = nn >>> 1) {
+    n2 = n2 << 1;
+    const n8 = n2 >>> 3;
+    const e = TWO_PI / n2;
+    const off = stages[si].offset << 2;
+    for (let j = 1; j < n8; j++) {
+      const a2 = j * e;
+      const s = sin2(a2), c = cos2(a2);
+      const idx = off + (j - 1 << 2);
+      tw[idx] = c;
+      tw[idx + 1] = s;
+      tw[idx + 2] = 4 * c * (c * c - 0.75);
+      tw[idx + 3] = 4 * s * (0.75 - s * s);
+    }
+    si++;
+  }
+  const entry = { x, spectrum, complex, bSi, tw, stages, perm };
+  cache.set(N, entry);
+  return entry;
+}
+function getEntry(N) {
+  if (N === lastN) return lastEntry;
+  const entry = cache.get(N) || init(N);
+  lastN = N;
+  lastEntry = entry;
+  return entry;
+}
+function transform(input) {
+  const N = input.length;
+  if (N < 2 || N & N - 1) throw Error("Input length must be a power of 2 (>= 2).");
+  const entry = getEntry(N);
+  const { x, tw, stages, perm } = entry;
+  for (let i = 0; i < N; i++) x[i] = input[perm[i]];
+  for (let ix = 0, id = 4; ix < N; id *= 4) {
+    for (let i0 = ix; i0 < N; i0 += id) {
+      const t = x[i0] - x[i0 + 1];
+      x[i0] += x[i0 + 1];
+      x[i0 + 1] = t;
+    }
+    ix = 2 * (id - 1);
+  }
+  let n2 = 2, nn = N >>> 1, si = 0;
+  while (nn = nn >>> 1) {
+    let ix = 0;
+    n2 = n2 << 1;
+    let id = n2 << 1;
+    const n4 = n2 >>> 2;
+    const n8 = n2 >>> 3;
+    do {
+      if (n4 !== 1) {
+        for (let i0 = ix; i0 < N; i0 += id) {
+          let i1 = i0, i2 = i1 + n4, i3 = i2 + n4, i4 = i3 + n4;
+          let t1 = x[i3] + x[i4];
+          x[i4] -= x[i3];
+          x[i3] = x[i1] - t1;
+          x[i1] += t1;
+          i1 += n8;
+          i2 += n8;
+          i3 += n8;
+          i4 += n8;
+          t1 = x[i3] + x[i4];
+          let t2 = x[i3] - x[i4];
+          t1 = -t1 * SQRT1_2;
+          t2 *= SQRT1_2;
+          const st1 = x[i2];
+          x[i4] = t1 + st1;
+          x[i3] = t1 - st1;
+          x[i2] = x[i1] - t2;
+          x[i1] += t2;
+        }
+      } else {
+        for (let i0 = ix; i0 < N; i0 += id) {
+          const i1 = i0, i3 = i1 + 2, i4 = i3 + 1;
+          const t1 = x[i3] + x[i4];
+          x[i4] -= x[i3];
+          x[i3] = x[i1] - t1;
+          x[i1] += t1;
+        }
+      }
+      ix = (id << 1) - n2;
+      id = id << 2;
+    } while (ix < N);
+    const { offset, count } = stages[si];
+    for (let j = 0; j < count; j++) {
+      const ti = offset + j << 2;
+      const cc1 = tw[ti], ss1 = tw[ti + 1], cc3 = tw[ti + 2], ss3 = tw[ti + 3];
+      ix = 0;
+      id = n2 << 1;
+      do {
+        for (let i0 = ix; i0 < N; i0 += id) {
+          const i1 = i0 + j + 1;
+          const i2 = i1 + n4;
+          const i3 = i2 + n4;
+          const i4 = i3 + n4;
+          const i5 = i0 + n4 - j - 1;
+          const i6 = i5 + n4;
+          const i7 = i6 + n4;
+          const i8 = i7 + n4;
+          let t2 = x[i7] * cc1 - x[i3] * ss1;
+          let t1 = x[i7] * ss1 + x[i3] * cc1;
+          let t4 = x[i8] * cc3 - x[i4] * ss3;
+          let t3 = x[i8] * ss3 + x[i4] * cc3;
+          const st1 = t2 - t4;
+          t2 += t4;
+          t4 = st1;
+          x[i8] = t2 + x[i6];
+          x[i3] = t2 - x[i6];
+          const st2 = t3 - t1;
+          t1 += t3;
+          t3 = st2;
+          x[i4] = t3 + x[i2];
+          x[i7] = t3 - x[i2];
+          x[i6] = x[i1] - t1;
+          x[i1] += t1;
+          x[i2] = t4 + x[i5];
+          x[i5] -= t4;
+        }
+        ix = (id << 1) - n2;
+        id = id << 2;
+      } while (ix < N);
+    }
+    si++;
+  }
+  return entry;
+}
+function rfft(input, output) {
+  const entry = transform(input);
+  const N = input.length;
+  const { x, spectrum, bSi } = entry;
+  const out = output || spectrum;
+  let i = N >>> 1;
+  while (--i) {
+    const rval = x[i], ival = x[N - i];
+    out[i] = bSi * sqrt2(rval * rval + ival * ival);
+  }
+  out[0] = abs(bSi * x[0]);
+  return out;
+}
+
+// node_modules/window-function/util.js
+var { cos: cos3, sin: sin3, abs: abs2, exp, sqrt: sqrt3, PI: PI2, cosh, acosh, acos, pow: pow2, log10 } = Math;
+var PI22 = 2 * PI2;
+
+// node_modules/window-function/hann.js
+function hann(i, N) {
+  return 0.5 - 0.5 * cos3(PI22 * i / (N - 1));
+}
+
+// node_modules/a-weighting/index.js
+function a(f) {
+  let f2 = f * f;
+  return 1.2588966 * 14884e4 * f2 * f2 / ((f2 + 424.36) * Math.sqrt((f2 + 11599.29) * (f2 + 544496.41)) * (f2 + 14884e4));
+}
+
+// fn/spectrum.js
+var toMel = (f) => 2595 * Math.log10(1 + f / 700);
+var fromMel = (m2) => 700 * (10 ** (m2 / 2595) - 1);
+var windows = {};
+function hannWin(n) {
+  if (windows[n]) return windows[n];
+  let w = new Float32Array(n);
+  for (let i = 0; i < n; i++) w[i] = hann(i, n);
+  return windows[n] = w;
+}
+function melSpectrum(samples, sr, opts = {}) {
+  let { bins = 128, fMin = 30, fMax = Math.min(sr / 2, 2e4), weight = true } = opts;
+  let N = samples.length, win = hannWin(N);
+  let buf = new Float32Array(N);
+  for (let i = 0; i < N; i++) buf[i] = samples[i] * win[i];
+  let mag = rfft(buf);
+  let mMin = toMel(fMin), mMax = toMel(fMax), binHz = sr / N;
+  let out = new Float32Array(bins);
+  for (let b = 0; b < bins; b++) {
+    let f0 = fromMel(mMin + (mMax - mMin) * b / bins);
+    let f1 = fromMel(mMin + (mMax - mMin) * (b + 1) / bins);
+    let k0 = Math.max(1, Math.floor(f0 / binHz));
+    let k1 = Math.min(mag.length - 1, Math.ceil(f1 / binHz));
+    let sum = 0, cnt = 0;
+    for (let k = k0; k <= k1; k++) {
+      sum += mag[k] ** 2;
+      cnt++;
+    }
+    let rms = cnt > 0 ? Math.sqrt(sum / cnt) : 0;
+    if (weight) rms *= a((f0 + f1) / 2, sr);
+    out[b] = rms;
+  }
+  return out;
+}
+async function analyzeBlocks(inst, opts, N, bins, fn3) {
+  let acc = new Float64Array(bins), cnt = 0, rem = new Float32Array(0);
+  for await (let pcm of inst.stream({ at: opts?.at, duration: opts?.duration })) {
+    let ch0 = pcm[0];
+    if (!ch0 || !ch0.length) continue;
+    let input = ch0;
+    if (rem.length) {
+      input = new Float32Array(rem.length + ch0.length);
+      input.set(rem, 0);
+      input.set(ch0, rem.length);
+    }
+    let limit = input.length - input.length % N;
+    for (let off = 0; off < limit; off += N) {
+      fn3(input.subarray(off, off + N), acc);
+      cnt++;
+    }
+    rem = limit < input.length ? input.slice(limit) : new Float32Array(0);
+  }
+  return { acc, cnt };
+}
+audio.fn.spectrum = async function(opts) {
+  let bins = opts?.bins ?? 128;
+  let spectOpts = { bins, fMin: opts?.fMin, fMax: opts?.fMax, weight: opts?.weight };
+  let sr = this.sampleRate;
+  let { acc, cnt } = await analyzeBlocks(this, opts, 1024, bins, (block, acc2) => {
+    let mag = melSpectrum(block, sr, spectOpts);
+    for (let b = 0; b < bins; b++) acc2[b] += mag[b] ** 2;
+  });
+  if (cnt === 0) return new Float32Array(bins);
+  let out = new Float32Array(bins);
+  for (let b = 0; b < bins; b++) out[b] = 20 * Math.log10(Math.sqrt(acc[b] / cnt) + 1e-10);
+  return out;
+};
+
+// fn/cepstrum.js
+function mfcc(samples, sr, opts = {}) {
+  let { bins = 13, nMel = 40 } = opts;
+  let mag = melSpectrum(samples, sr, { bins: nMel, weight: false });
+  let logMel = new Float32Array(nMel);
+  for (let i = 0; i < nMel; i++) logMel[i] = Math.log(mag[i] ** 2 + 1e-10);
+  let out = new Float32Array(bins);
+  for (let k = 0; k < bins; k++) {
+    let sum = 0;
+    for (let n = 0; n < nMel; n++) sum += logMel[n] * Math.cos(Math.PI * k * (2 * n + 1) / (2 * nMel));
+    out[k] = sum;
+  }
+  return out;
+}
+audio.fn.cepstrum = async function(opts) {
+  let bins = opts?.bins ?? 13;
+  let sr = this.sampleRate;
+  let { acc, cnt } = await analyzeBlocks(this, opts, 1024, bins, (block, acc2) => {
+    let c = mfcc(block, sr, { bins });
+    for (let k = 0; k < bins; k++) acc2[k] += c[k];
+  });
+  if (cnt === 0) return new Float32Array(bins);
+  let out = new Float32Array(bins);
+  for (let k = 0; k < bins; k++) out[k] = acc[k] / cnt;
+  return out;
+};
+
+// fn/silence.js
+audio.fn.silence = async function(opts) {
+  let { stats, ch, sr, from, to } = await queryRange(this, opts);
+  let bs = stats.blockSize;
+  let minDur = opts?.minDuration ?? 0.1;
+  let thresh = resolveThreshold(stats, ch, from, to, opts?.threshold);
+  let segs = [], start = null;
+  for (let i = from; i < to; i++) {
+    if (!isLoud(stats, i, ch, thresh)) {
+      if (start == null) start = i;
+    } else if (start != null) {
+      let segAt = start * bs / sr, segEnd = i * bs / sr;
+      if (segEnd - segAt >= minDur) segs.push({ at: segAt, duration: segEnd - segAt });
+      start = null;
+    }
+  }
+  if (start != null) {
+    let segAt = start * bs / sr, segEnd = Math.min(to * bs / sr, this.duration);
+    if (segEnd - segAt >= minDur) segs.push({ at: segAt, duration: segEnd - segAt });
+  }
+  return segs;
+};
+export {
+  audio as default,
+  parseTime,
+  render
+};