@blockcast/mmt-render 0.1.0

package/dist/audio/audio-ring-buffer.js

@@ -0,0 +1,255 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/audio/audio-ring-buffer.ts
+var _buffer, _writeIndex, _readIndex, _stalled, _startupFrames, _resumeFrames, _resumeFollowsStartup, _hasStarted, _capacityHeadroomFrames, _timestampAnchors, _diagEnabled, _diagReads, _diagFillSum, _diagOverflowSamples, _AudioRingBuffer_instances, pruneTimestampAnchors_fn, refillFrames_fn;
+var AudioRingBuffer = class {
+  constructor(config) {
+    __privateAdd(this, _AudioRingBuffer_instances);
+    __privateAdd(this, _buffer);
+    __privateAdd(this, _writeIndex, 0);
+    __privateAdd(this, _readIndex, 0);
+    __privateAdd(this, _stalled);
+    __privateAdd(this, _startupFrames);
+    __privateAdd(this, _resumeFrames);
+    __privateAdd(this, _resumeFollowsStartup);
+    __privateAdd(this, _hasStarted);
+    __privateAdd(this, _capacityHeadroomFrames);
+    __privateAdd(this, _timestampAnchors, []);
+    __privateAdd(this, _diagEnabled);
+    __privateAdd(this, _diagReads, 0);
+    __privateAdd(this, _diagFillSum, 0);
+    __privateAdd(this, _diagOverflowSamples, 0);
+    if (!Number.isInteger(config.channels) || config.channels <= 0) {
+      throw new Error("invalid channels");
+    }
+    if (!Number.isFinite(config.rate) || config.rate <= 0) {
+      throw new Error("invalid sample rate");
+    }
+    if (!Number.isFinite(config.latencyMs) || config.latencyMs <= 0) {
+      throw new Error("invalid latency");
+    }
+    const latencyFrames = Math.ceil(config.rate * (config.latencyMs / 1e3));
+    const startupFrames = config.startupFrames ?? latencyFrames;
+    const resumeFrames = config.resumeFrames ?? startupFrames;
+    const thresholdFrames = Math.max(startupFrames, resumeFrames);
+    const capacityFrames = config.capacityFrames ?? Math.max(latencyFrames, thresholdFrames);
+    if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {
+      throw new Error("invalid startup frames");
+    }
+    if (!Number.isSafeInteger(resumeFrames) || resumeFrames <= 0) {
+      throw new Error("invalid resume frames");
+    }
+    if (!Number.isSafeInteger(capacityFrames) || capacityFrames < thresholdFrames) {
+      throw new Error("invalid capacity frames");
+    }
+    this.channels = config.channels;
+    this.rate = config.rate;
+    __privateSet(this, _startupFrames, startupFrames);
+    __privateSet(this, _resumeFrames, resumeFrames);
+    __privateSet(this, _resumeFollowsStartup, config.resumeFrames === void 0);
+    __privateSet(this, _hasStarted, config.startUnstalled ?? false);
+    __privateSet(this, _capacityHeadroomFrames, capacityFrames - thresholdFrames);
+    __privateSet(this, _stalled, !(config.startUnstalled ?? false));
+    __privateSet(this, _diagEnabled, config.diag ?? false);
+    __privateSet(this, _buffer, Array.from(
+      { length: config.channels },
+      () => new Float32Array(capacityFrames)
+    ));
+  }
+  get stalled() {
+    return __privateGet(this, _stalled);
+  }
+  get startupFrames() {
+    return __privateGet(this, _startupFrames);
+  }
+  get capacity() {
+    return __privateGet(this, _buffer)[0].length;
+  }
+  get length() {
+    return __privateGet(this, _writeIndex) - __privateGet(this, _readIndex);
+  }
+  /** Timestamp of the next media sample after the PCM already emitted. */
+  get timestampUs() {
+    const anchor = __privateGet(this, _timestampAnchors)[0];
+    if (!anchor || anchor.sampleIndex > __privateGet(this, _readIndex)) return void 0;
+    return anchor.timestampUs + (__privateGet(this, _readIndex) - anchor.sampleIndex) / this.rate * 1e6;
+  }
+  write(timestampUs, data) {
+    if (data.length !== this.channels) throw new Error("wrong channel count");
+    if (!Number.isFinite(timestampUs)) throw new Error("invalid timestamp");
+    const samples = data[0].length;
+    if (samples === 0) return;
+    if (data.some((channel) => channel.length !== samples)) {
+      throw new Error("mismatched channel lengths");
+    }
+    const start = __privateGet(this, _writeIndex);
+    const end = start + samples;
+    __privateGet(this, _timestampAnchors).push({ sampleIndex: start, timestampUs });
+    const overflow = end - __privateGet(this, _readIndex) - this.capacity;
+    if (overflow > 0) {
+      __privateSet(this, _stalled, false);
+      __privateSet(this, _hasStarted, true);
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + overflow);
+      if (__privateGet(this, _diagEnabled)) __privateSet(this, _diagOverflowSamples, __privateGet(this, _diagOverflowSamples) + overflow);
+      __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    }
+    const refillFrames = __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+    if (__privateGet(this, _stalled) && end - __privateGet(this, _readIndex) >= refillFrames) {
+      __privateSet(this, _stalled, false);
+      __privateSet(this, _hasStarted, true);
+    }
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = data[channel];
+      const dst = __privateGet(this, _buffer)[channel];
+      for (let i = 0; i < samples; i++) {
+        dst[(start + i) % dst.length] = src[i];
+      }
+    }
+    __privateSet(this, _writeIndex, end);
+  }
+  read(output) {
+    if (output.length !== this.channels) throw new Error("wrong channel count");
+    if (__privateGet(this, _stalled)) return 0;
+    const available = this.length;
+    if (available === 0) {
+      __privateSet(this, _stalled, true);
+      return 0;
+    }
+    const requested = output[0].length;
+    const readSamples = Math.min(available, requested);
+    for (let channel = 0; channel < this.channels; channel++) {
+      const dst = output[channel];
+      const src = __privateGet(this, _buffer)[channel];
+      for (let i = 0; i < readSamples; i++) {
+        dst[i] = src[(__privateGet(this, _readIndex) + i) % src.length];
+      }
+      for (let i = readSamples; i < requested; i++) dst[i] = 0;
+    }
+    __privateSet(this, _readIndex, __privateGet(this, _readIndex) + readSamples);
+    __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    if (readSamples < requested) __privateSet(this, _stalled, true);
+    if (__privateGet(this, _diagEnabled)) {
+      __privateWrapper(this, _diagReads)._++;
+      __privateSet(this, _diagFillSum, __privateGet(this, _diagFillSum) + available);
+    }
+    return readSamples;
+  }
+  /** Clear queued PCM; optionally treat the next fill as post-start recovery. */
+  reset(startUnstalled = false, resumeAfterReset = false) {
+    __privateSet(this, _writeIndex, 0);
+    __privateSet(this, _readIndex, 0);
+    __privateSet(this, _stalled, !startUnstalled);
+    __privateSet(this, _hasStarted, startUnstalled || resumeAfterReset);
+    __privateSet(this, _timestampAnchors, []);
+    __privateSet(this, _diagReads, 0);
+    __privateSet(this, _diagFillSum, 0);
+    __privateSet(this, _diagOverflowSamples, 0);
+  }
+  /**
+   * Change the startup latency while preserving the configured storage
+   * headroom above its buffering thresholds. Active playout keeps draining
+   * retained PCM; a stalled buffer waits for its startup or resume threshold.
+   */
+  resize(latencyMs) {
+    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
+      throw new Error("invalid latency");
+    }
+    const newStartupFrames = Math.ceil(this.rate * (latencyMs / 1e3));
+    if (!Number.isSafeInteger(newStartupFrames) || newStartupFrames <= 0) {
+      throw new Error("invalid latency");
+    }
+    const newResumeFrames = __privateGet(this, _resumeFollowsStartup) ? newStartupFrames : __privateGet(this, _resumeFrames);
+    const newCapacity = Math.max(newStartupFrames, newResumeFrames) + __privateGet(this, _capacityHeadroomFrames);
+    if (!Number.isSafeInteger(newCapacity) || newCapacity < Math.max(newStartupFrames, newResumeFrames)) {
+      throw new Error("invalid capacity frames");
+    }
+    const wasStalled = __privateGet(this, _stalled);
+    __privateSet(this, _startupFrames, newStartupFrames);
+    __privateSet(this, _resumeFrames, newResumeFrames);
+    if (newCapacity === this.capacity) {
+      if (wasStalled && this.length >= __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this)) {
+        __privateSet(this, _stalled, false);
+        __privateSet(this, _hasStarted, true);
+      }
+      return;
+    }
+    const next = Array.from(
+      { length: this.channels },
+      () => new Float32Array(newCapacity)
+    );
+    const samplesToKeep = Math.min(this.length, newCapacity);
+    const copyStart = __privateGet(this, _writeIndex) - samplesToKeep;
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = __privateGet(this, _buffer)[channel];
+      const dst = next[channel];
+      for (let i = 0; i < samplesToKeep; i++) {
+        const sampleIndex = copyStart + i;
+        dst[sampleIndex % dst.length] = src[sampleIndex % src.length];
+      }
+    }
+    __privateSet(this, _buffer, next);
+    __privateSet(this, _readIndex, copyStart);
+    __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+    __privateSet(this, _stalled, samplesToKeep === 0 || wasStalled && samplesToKeep < __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this));
+    if (!__privateGet(this, _stalled)) __privateSet(this, _hasStarted, true);
+  }
+  getDiagAndReset() {
+    if (!__privateGet(this, _diagEnabled) || __privateGet(this, _diagReads) === 0) return null;
+    const result = {
+      reads: __privateGet(this, _diagReads),
+      avgFill: Math.round(__privateGet(this, _diagFillSum) / __privateGet(this, _diagReads)),
+      capacity: this.capacity,
+      skips: 0,
+      dups: 0,
+      overflowSamples: __privateGet(this, _diagOverflowSamples)
+    };
+    __privateSet(this, _diagReads, 0);
+    __privateSet(this, _diagFillSum, 0);
+    __privateSet(this, _diagOverflowSamples, 0);
+    return result;
+  }
+};
+_buffer = new WeakMap();
+_writeIndex = new WeakMap();
+_readIndex = new WeakMap();
+_stalled = new WeakMap();
+_startupFrames = new WeakMap();
+_resumeFrames = new WeakMap();
+_resumeFollowsStartup = new WeakMap();
+_hasStarted = new WeakMap();
+_capacityHeadroomFrames = new WeakMap();
+_timestampAnchors = new WeakMap();
+_diagEnabled = new WeakMap();
+_diagReads = new WeakMap();
+_diagFillSum = new WeakMap();
+_diagOverflowSamples = new WeakMap();
+_AudioRingBuffer_instances = new WeakSet();
+pruneTimestampAnchors_fn = function() {
+  let keep = 0;
+  while (keep + 1 < __privateGet(this, _timestampAnchors).length && __privateGet(this, _timestampAnchors)[keep + 1].sampleIndex <= __privateGet(this, _readIndex)) {
+    keep++;
+  }
+  if (keep > 0) __privateGet(this, _timestampAnchors).splice(0, keep);
+};
+refillFrames_fn = function() {
+  return __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+};
+export {
+  AudioRingBuffer
+};
+//# sourceMappingURL=audio-ring-buffer.js.map

package/dist/audio/audio-ring-buffer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/audio/audio-ring-buffer.ts"],
+  "sourcesContent": ["/**\n * Timestamp-anchored FIFO shared by MMT AudioWorklet consumers.\n *\n * PCM remains in decoder emission order. Media timestamps are exact anchors\n * for playout reporting only; they never reposition samples or trigger a\n * guessed discontinuity. The FIFO starts after its full catalog-derived\n * latency is buffered and performs no sample skip/dup clock recovery.\n */\n\nexport interface AudioRingBufferConfig {\n  channels: number\n  rate: number\n  latencyMs: number\n  /** Exact PCM startup threshold. Overrides latencyMs when provided. */\n  startupFrames?: number\n  /** PCM refill threshold after the first underrun. Defaults to startupFrames. */\n  resumeFrames?: number\n  /** Exact PCM storage ceiling. Must cover the startup and resume thresholds. */\n  capacityFrames?: number\n  startUnstalled?: boolean\n  /** Deprecated compatibility input. Clock recovery is not performed. */\n  warmupReads?: number\n  diag?: boolean\n}\n\nexport interface AudioRingBufferDiag {\n  reads: number\n  avgFill: number\n  capacity: number\n  skips: number\n  dups: number\n  overflowSamples: number\n}\n\ntype TimestampAnchor = {\n  sampleIndex: number\n  timestampUs: number\n}\n\nexport class AudioRingBuffer {\n  readonly channels: number\n  readonly rate: number\n\n  #buffer: Float32Array[]\n  #writeIndex = 0\n  #readIndex = 0\n  #stalled: boolean\n  #startupFrames: number\n  #resumeFrames: number\n  #resumeFollowsStartup: boolean\n  #hasStarted: boolean\n  #capacityHeadroomFrames: number\n  #timestampAnchors: TimestampAnchor[] = []\n\n  #diagEnabled: boolean\n  #diagReads = 0\n  #diagFillSum = 0\n  #diagOverflowSamples = 0\n\n  constructor(config: AudioRingBufferConfig) {\n    if (!Number.isInteger(config.channels) || config.channels <= 0) {\n      throw new Error('invalid channels')\n    }\n    if (!Number.isFinite(config.rate) || config.rate <= 0) {\n      throw new Error('invalid sample rate')\n    }\n    if (!Number.isFinite(config.latencyMs) || config.latencyMs <= 0) {\n      throw new Error('invalid latency')\n    }\n\n    const latencyFrames = Math.ceil(config.rate * (config.latencyMs / 1000))\n    const startupFrames = config.startupFrames ?? latencyFrames\n    const resumeFrames = config.resumeFrames ?? startupFrames\n    const thresholdFrames = Math.max(startupFrames, resumeFrames)\n    const capacityFrames = config.capacityFrames ?? Math.max(latencyFrames, thresholdFrames)\n    if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {\n      throw new Error('invalid startup frames')\n    }\n    if (!Number.isSafeInteger(resumeFrames) || resumeFrames <= 0) {\n      throw new Error('invalid resume frames')\n    }\n    if (!Number.isSafeInteger(capacityFrames) || capacityFrames < thresholdFrames) {\n      throw new Error('invalid capacity frames')\n    }\n\n    this.channels = config.channels\n    this.rate = config.rate\n    this.#startupFrames = startupFrames\n    this.#resumeFrames = resumeFrames\n    this.#resumeFollowsStartup = config.resumeFrames === undefined\n    this.#hasStarted = config.startUnstalled ?? false\n    this.#capacityHeadroomFrames = capacityFrames - thresholdFrames\n    this.#stalled = !(config.startUnstalled ?? false)\n    this.#diagEnabled = config.diag ?? false\n    this.#buffer = Array.from(\n      { length: config.channels },\n      () => new Float32Array(capacityFrames),\n    )\n  }\n\n  get stalled(): boolean { return this.#stalled }\n  get startupFrames(): number { return this.#startupFrames }\n  get capacity(): number { return this.#buffer[0].length }\n  get length(): number { return this.#writeIndex - this.#readIndex }\n\n  /** Timestamp of the next media sample after the PCM already emitted. */\n  get timestampUs(): number | undefined {\n    const anchor = this.#timestampAnchors[0]\n    if (!anchor || anchor.sampleIndex > this.#readIndex) return undefined\n    return anchor.timestampUs + ((this.#readIndex - anchor.sampleIndex) / this.rate) * 1_000_000\n  }\n\n  write(timestampUs: number, data: Float32Array[]): void {\n    if (data.length !== this.channels) throw new Error('wrong channel count')\n    if (!Number.isFinite(timestampUs)) throw new Error('invalid timestamp')\n    const samples = data[0].length\n    if (samples === 0) return\n    if (data.some((channel) => channel.length !== samples)) {\n      throw new Error('mismatched channel lengths')\n    }\n\n    const start = this.#writeIndex\n    const end = start + samples\n    this.#timestampAnchors.push({ sampleIndex: start, timestampUs })\n\n    const overflow = end - this.#readIndex - this.capacity\n    if (overflow > 0) {\n      this.#stalled = false\n      this.#hasStarted = true\n      this.#readIndex += overflow\n      if (this.#diagEnabled) this.#diagOverflowSamples += overflow\n      this.#pruneTimestampAnchors()\n    }\n\n    const refillFrames = this.#hasStarted ? this.#resumeFrames : this.#startupFrames\n    if (this.#stalled && end - this.#readIndex >= refillFrames) {\n      this.#stalled = false\n      this.#hasStarted = true\n    }\n\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = data[channel]\n      const dst = this.#buffer[channel]\n      for (let i = 0; i < samples; i++) {\n        dst[(start + i) % dst.length] = src[i]\n      }\n    }\n    this.#writeIndex = end\n  }\n\n  read(output: Float32Array[]): number {\n    if (output.length !== this.channels) throw new Error('wrong channel count')\n    if (this.#stalled) return 0\n\n    const available = this.length\n    if (available === 0) {\n      this.#stalled = true\n      return 0\n    }\n\n    const requested = output[0].length\n    const readSamples = Math.min(available, requested)\n\n    for (let channel = 0; channel < this.channels; channel++) {\n      const dst = output[channel]\n      const src = this.#buffer[channel]\n      for (let i = 0; i < readSamples; i++) {\n        dst[i] = src[(this.#readIndex + i) % src.length]\n      }\n      for (let i = readSamples; i < requested; i++) dst[i] = 0\n    }\n\n    this.#readIndex += readSamples\n    this.#pruneTimestampAnchors()\n    if (readSamples < requested) this.#stalled = true\n\n    if (this.#diagEnabled) {\n      this.#diagReads++\n      this.#diagFillSum += available\n    }\n    return readSamples\n  }\n\n  /** Clear queued PCM; optionally treat the next fill as post-start recovery. */\n  reset(startUnstalled = false, resumeAfterReset = false): void {\n    this.#writeIndex = 0\n    this.#readIndex = 0\n    this.#stalled = !startUnstalled\n    this.#hasStarted = startUnstalled || resumeAfterReset\n    this.#timestampAnchors = []\n    this.#diagReads = 0\n    this.#diagFillSum = 0\n    this.#diagOverflowSamples = 0\n  }\n\n  /**\n   * Change the startup latency while preserving the configured storage\n   * headroom above its buffering thresholds. Active playout keeps draining\n   * retained PCM; a stalled buffer waits for its startup or resume threshold.\n   */\n  resize(latencyMs: number): void {\n    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {\n      throw new Error('invalid latency')\n    }\n    const newStartupFrames = Math.ceil(this.rate * (latencyMs / 1000))\n    if (!Number.isSafeInteger(newStartupFrames) || newStartupFrames <= 0) {\n      throw new Error('invalid latency')\n    }\n    const newResumeFrames = this.#resumeFollowsStartup ? newStartupFrames : this.#resumeFrames\n    const newCapacity =\n      Math.max(newStartupFrames, newResumeFrames) + this.#capacityHeadroomFrames\n    if (\n      !Number.isSafeInteger(newCapacity) ||\n      newCapacity < Math.max(newStartupFrames, newResumeFrames)\n    ) {\n      throw new Error('invalid capacity frames')\n    }\n    const wasStalled = this.#stalled\n    this.#startupFrames = newStartupFrames\n    this.#resumeFrames = newResumeFrames\n    if (newCapacity === this.capacity) {\n      if (wasStalled && this.length >= this.#refillFrames()) {\n        this.#stalled = false\n        this.#hasStarted = true\n      }\n      return\n    }\n\n    const next = Array.from(\n      { length: this.channels },\n      () => new Float32Array(newCapacity),\n    )\n    const samplesToKeep = Math.min(this.length, newCapacity)\n    const copyStart = this.#writeIndex - samplesToKeep\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = this.#buffer[channel]\n      const dst = next[channel]\n      for (let i = 0; i < samplesToKeep; i++) {\n        const sampleIndex = copyStart + i\n        dst[sampleIndex % dst.length] = src[sampleIndex % src.length]\n      }\n    }\n\n    this.#buffer = next\n    this.#readIndex = copyStart\n    this.#pruneTimestampAnchors()\n    this.#stalled = samplesToKeep === 0 || (wasStalled && samplesToKeep < this.#refillFrames())\n    if (!this.#stalled) this.#hasStarted = true\n  }\n\n  getDiagAndReset(): AudioRingBufferDiag | null {\n    if (!this.#diagEnabled || this.#diagReads === 0) return null\n    const result: AudioRingBufferDiag = {\n      reads: this.#diagReads,\n      avgFill: Math.round(this.#diagFillSum / this.#diagReads),\n      capacity: this.capacity,\n      skips: 0,\n      dups: 0,\n      overflowSamples: this.#diagOverflowSamples,\n    }\n    this.#diagReads = 0\n    this.#diagFillSum = 0\n    this.#diagOverflowSamples = 0\n    return result\n  }\n\n  #pruneTimestampAnchors(): void {\n    let keep = 0\n    while (\n      keep + 1 < this.#timestampAnchors.length &&\n      this.#timestampAnchors[keep + 1].sampleIndex <= this.#readIndex\n    ) {\n      keep++\n    }\n    if (keep > 0) this.#timestampAnchors.splice(0, keep)\n  }\n\n  #refillFrames(): number {\n    return this.#hasStarted ? this.#resumeFrames : this.#startupFrames\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/audio/index.d.ts

@@ -0,0 +1,9 @@
+export { AudioRingBuffer } from './audio-ring-buffer.js';
+export type { AudioRingBufferConfig, AudioRingBufferDiag } from './audio-ring-buffer.js';
+export { deriveAudioBurstBufferPlan } from './audio-buffer-plan.js';
+export type { AudioBurstBufferPlan, AudioBurstBufferPlanInput } from './audio-buffer-plan.js';
+export { AudioRenderPipeline } from './audio-render-pipeline.js';
+export type { AudioRenderPipelineOpts } from './audio-render-pipeline.js';
+export type { FromMain, ToMain, InitMessage, DataMessage, StartMessage, WriteAckMessage, LatencyMessage, ResetMessage, DiagRequestMessage, StateMessage, DiagMessage, } from './render-messages.js';
+export { WORKLET_PROCESSOR_NAME, workletModuleUrl } from './worklet-url.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/audio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/audio/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACxF,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAA;AACnE,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,YAAY,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAIzE,YAAY,EACV,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EACzF,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,WAAW,GAC5D,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}