audio-chunkify 1.0.0

package/dist/index.js

@@ -0,0 +1,746 @@
+// src/constants.ts
+var DEFAULT_AUDIO_CONSTANTS = {
+  /** FFT size for the AnalyserNode (must be a power of 2). Affects frequency resolution. */
+  ANALYSIS_BUFFER_SIZE: 2048,
+  /** Silence threshold in dB used for chunk splitting (-Infinity to 0). */
+  SILENCE_THRESHOLD: -50,
+  /** Maximum chunk duration in seconds before a forced split. */
+  MAX_CHUNK_DURATION: 300,
+  /** Minimum chunk duration in seconds before a silence-based split is allowed. */
+  MIN_CHUNK_DURATION: 30,
+  /** Minimum continuous silence duration in seconds required to trigger a split. */
+  MIN_SILENCE_DURATION: 1
+};
+
+// src/utils/audioCodec.ts
+var PREFERRED_MIME_TYPES = [
+  "audio/webm;codecs=opus",
+  "audio/webm",
+  "audio/mp4;codecs=mp4a.40.2",
+  "audio/mp4",
+  "audio/ogg;codecs=opus",
+  "audio/ogg"
+];
+function getCompatibleMimeType() {
+  if (typeof MediaRecorder === "undefined") {
+    return null;
+  }
+  for (const mimeType of PREFERRED_MIME_TYPES) {
+    if (MediaRecorder.isTypeSupported(mimeType)) {
+      return mimeType;
+    }
+  }
+  return null;
+}
+function getFileExtensionFromMimeType(mimeType) {
+  if (!mimeType) return "webm";
+  if (mimeType.startsWith("audio/mp4")) return "mp4";
+  if (mimeType.startsWith("audio/ogg")) return "ogg";
+  if (mimeType.startsWith("audio/webm")) return "webm";
+  const match = mimeType.match(/audio\/(\w+)/);
+  return match?.[1] ?? "webm";
+}
+
+// src/AudioChunkify.ts
+var AudioChunkify = class {
+  constructor() {
+    // ── Core recorder ────────────────────────────────────────────────────────
+    this._mediaRecorder = null;
+    this._stream = null;
+    this._audioStreams = [];
+    this._mimeType = null;
+    this._timeslice = null;
+    // ── Event callbacks ───────────────────────────────────────────────────────
+    this._onDataAvailableCallback = null;
+    this._onStartCallback = null;
+    this._onPauseCallback = null;
+    this._onResumeCallback = null;
+    this._onStopCallback = null;
+    this._onErrorCallback = null;
+    // ── Time tracking ─────────────────────────────────────────────────────────
+    this._recordingTime = 0;
+    this._intervalId = null;
+    this._onTimeUpdateCallback = null;
+    // ── Silence analysis ─────────────────────────────────────────────────────
+    this._audioContext = null;
+    this._analyserNode = null;
+    this._sourceNode = null;
+    this._silenceTime = 0;
+    this._silenceIntervalId = null;
+    this._silenceCheckIntervalId = null;
+    this._silenceThreshold = DEFAULT_AUDIO_CONSTANTS.SILENCE_THRESHOLD;
+    this._isInSilence = false;
+    this._onSilenceDetectedCallback = null;
+    this._onAudioDetectedCallback = null;
+    // ── Mixed stream ──────────────────────────────────────────────────────────
+    this._mixedStreamContext = null;
+    this._mixedStreamDestination = null;
+    this._mixedStreamSourceNodes = [];
+    // ── Chunk management ─────────────────────────────────────────────────────
+    this._audioChunks = [];
+    this._currentChunkIndex = 0;
+    this._processingChunk = false;
+    this._isChunkSplit = false;
+    this._lastChunkEnd = null;
+    this._silenceStartForChunking = null;
+    this._chunkSplitIntervalId = null;
+    this._onChunkProcessedCallback = null;
+    this._pauseStartTime = null;
+    this._totalPausedTime = 0;
+    // ── Chunk options ─────────────────────────────────────────────────────────
+    this._chunkOptions = {
+      maxDuration: DEFAULT_AUDIO_CONSTANTS.MAX_CHUNK_DURATION,
+      minDuration: DEFAULT_AUDIO_CONSTANTS.MIN_CHUNK_DURATION,
+      minSilenceDuration: DEFAULT_AUDIO_CONSTANTS.MIN_SILENCE_DURATION
+    };
+  }
+  // ── Public API ────────────────────────────────────────────────────────────
+  /**
+   * Initialises the recorder with the given stream and options.
+   *
+   * @example
+   * const recorder = new AudioChunkify()
+   * const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+   * recorder.create(stream, { timeslice: 250 })
+   */
+  create(stream, options = {}) {
+    if (!(stream instanceof MediaStream)) {
+      throw new TypeError("stream must be a MediaStream instance.");
+    }
+    if (options.mimeType) {
+      if (!MediaRecorder.isTypeSupported(options.mimeType)) {
+        throw new Error(`MIME type "${options.mimeType}" is not supported by this browser.`);
+      }
+      this._mimeType = options.mimeType;
+    } else {
+      this._mimeType = getCompatibleMimeType();
+    }
+    this._timeslice = options.timeslice ?? null;
+    if (options.silenceThreshold !== void 0) {
+      this.setSilenceThreshold(options.silenceThreshold);
+    }
+    if (options.chunkOptions) {
+      this._chunkOptions = { ...this._chunkOptions, ...options.chunkOptions };
+    }
+    this._audioStreams = [stream];
+    this._stream = this._createMixedStream();
+    const recorderOptions = {};
+    if (this._mimeType) recorderOptions.mimeType = this._mimeType;
+    this._mediaRecorder = new MediaRecorder(this._stream, recorderOptions);
+    this._setupEventHandlers();
+    this._setupAudioAnalysis();
+    return this._mediaRecorder;
+  }
+  /** Starts recording. Optionally overrides the timeslice set in create(). */
+  start(timeslice) {
+    const mr = this._assertReady();
+    if (mr.state === "recording") {
+      console.warn("[AudioChunkify] Already recording.");
+      return;
+    }
+    this._silenceStartForChunking = null;
+    const slice = timeslice ?? this._timeslice;
+    if (slice !== null && slice !== void 0) {
+      mr.start(slice);
+    } else {
+      mr.start();
+    }
+  }
+  /** Pauses an active recording. */
+  pause() {
+    const mr = this._assertReady();
+    if (mr.state === "recording") {
+      mr.pause();
+    } else {
+      console.warn(`[AudioChunkify] Cannot pause \u2014 state is "${mr.state}".`);
+    }
+  }
+  /** Resumes a paused recording. */
+  resume() {
+    const mr = this._assertReady();
+    if (mr.state === "paused") {
+      mr.resume();
+    } else {
+      console.warn(`[AudioChunkify] Cannot resume \u2014 state is "${mr.state}".`);
+    }
+  }
+  /** Stops the recording and finalises all pending chunks. */
+  stop() {
+    const mr = this._assertReady();
+    this._stopChunkSplitting();
+    if (mr.state !== "inactive") {
+      mr.stop();
+    }
+  }
+  /**
+   * Dynamically mixes in an additional audio stream.
+   * The recorder is briefly restarted to rebuild the AudioContext graph.
+   */
+  addAudioStream(stream) {
+    if (!(stream instanceof MediaStream)) {
+      throw new TypeError("stream must be a MediaStream instance.");
+    }
+    this._assertReady();
+    if (this._audioStreams.includes(stream)) {
+      console.warn("[AudioChunkify] Stream is already being mixed.");
+      return;
+    }
+    const { wasRecording, wasPaused } = this._captureState();
+    if (wasRecording || wasPaused) this._mediaRecorder?.stop();
+    this._audioStreams.push(stream);
+    this._recreateMediaRecorder();
+    this._restoreState(wasRecording, wasPaused);
+  }
+  /**
+   * Removes a previously added audio stream from the mix.
+   * At least one stream must remain — call destroy() to tear everything down.
+   */
+  removeAudioStream(stream) {
+    this._assertReady();
+    const index = this._audioStreams.indexOf(stream);
+    if (index === -1) {
+      console.warn("[AudioChunkify] Stream not found.");
+      return;
+    }
+    if (this._audioStreams.length === 1) {
+      throw new Error(
+        "Cannot remove the last stream. Call destroy() to clean up instead."
+      );
+    }
+    const { wasRecording, wasPaused } = this._captureState();
+    if (wasRecording || wasPaused) this._mediaRecorder?.stop();
+    this._audioStreams.splice(index, 1);
+    this._recreateMediaRecorder();
+    this._restoreState(wasRecording, wasPaused);
+  }
+  // ── State & metadata ──────────────────────────────────────────────────────
+  /** Current recorder state: 'inactive' | 'recording' | 'paused' */
+  getState() {
+    return this._mediaRecorder?.state ?? "inactive";
+  }
+  /** Active MIME type (resolved at create() time). */
+  getMimeType() {
+    return this._mimeType;
+  }
+  /** The mixed MediaStream used internally by the recorder. */
+  getStream() {
+    return this._stream;
+  }
+  /** The underlying MediaRecorder instance. */
+  getMediaRecorder() {
+    return this._mediaRecorder;
+  }
+  /** Elapsed recording time in seconds (excludes paused time). */
+  getRecordingTime() {
+    return this._recordingTime;
+  }
+  /** Resets the elapsed recording time counter to zero. */
+  resetRecordingTime() {
+    this._recordingTime = 0;
+    this._onTimeUpdateCallback?.(this._recordingTime);
+  }
+  /** Current continuous silence duration in seconds. */
+  getSilenceTime() {
+    return this._silenceTime;
+  }
+  /** Current silence detection threshold in dB. */
+  getSilenceThreshold() {
+    return this._silenceThreshold;
+  }
+  /**
+   * Updates the silence detection threshold.
+   * @param threshold — Must be a negative number in dB (e.g. -50).
+   */
+  setSilenceThreshold(threshold) {
+    if (typeof threshold !== "number" || threshold > 0) {
+      throw new RangeError("Silence threshold must be a negative number (dB).");
+    }
+    this._silenceThreshold = threshold;
+  }
+  /** Accumulated audio chunks since the last start() or split. */
+  getAudioChunks() {
+    return [...this._audioChunks];
+  }
+  /** Zero-based index of the current chunk. */
+  getCurrentChunkIndex() {
+    return this._currentChunkIndex;
+  }
+  /** Clears the internal chunk buffer. */
+  clearAudioChunks() {
+    this._audioChunks = [];
+  }
+  // ── Event registration ────────────────────────────────────────────────────
+  onDataAvailable(callback) {
+    this._assertCallback(callback);
+    this._onDataAvailableCallback = callback;
+    if (this._mediaRecorder) this._mediaRecorder.ondataavailable = callback;
+    return this;
+  }
+  onStart(callback) {
+    this._assertCallback(callback);
+    this._onStartCallback = callback;
+    if (this._mediaRecorder) this._setupEventHandlers();
+    return this;
+  }
+  onPause(callback) {
+    this._assertCallback(callback);
+    this._onPauseCallback = callback;
+    if (this._mediaRecorder) this._setupEventHandlers();
+    return this;
+  }
+  onResume(callback) {
+    this._assertCallback(callback);
+    this._onResumeCallback = callback;
+    if (this._mediaRecorder) this._setupEventHandlers();
+    return this;
+  }
+  onStop(callback) {
+    this._assertCallback(callback);
+    this._onStopCallback = callback;
+    if (this._mediaRecorder) this._setupEventHandlers();
+    return this;
+  }
+  onError(callback) {
+    this._assertCallback(callback);
+    this._onErrorCallback = callback;
+    if (this._mediaRecorder) this._mediaRecorder.onerror = callback;
+    return this;
+  }
+  onTimeUpdate(callback) {
+    this._assertCallback(callback);
+    this._onTimeUpdateCallback = callback;
+    return this;
+  }
+  onSilenceDetected(callback) {
+    this._assertCallback(callback);
+    this._onSilenceDetectedCallback = callback;
+    return this;
+  }
+  onAudioDetected(callback) {
+    this._assertCallback(callback);
+    this._onAudioDetectedCallback = callback;
+    return this;
+  }
+  /**
+   * Called each time a chunk is finalised (either by splitting or on stop).
+   *
+   * @example
+   * recorder.onChunkProcessed(async ({ file, index, duration, isLastChunk }) => {
+   *   await uploadChunk(file)
+   *   if (isLastChunk) console.log('Recording complete')
+   * })
+   */
+  onChunkProcessed(callback) {
+    this._assertCallback(callback);
+    this._onChunkProcessedCallback = callback;
+    return this;
+  }
+  /**
+   * Fully tears down the recorder: stops recording, closes AudioContexts
+   * and clears all internal state.
+   *
+   * By default also stops every track on the input streams. Pass
+   * `{ stopStreams: false }` to keep those streams alive for reuse.
+   */
+  destroy(options = {}) {
+    const { stopStreams = true } = options;
+    if (this._mediaRecorder?.state !== "inactive") {
+      this._mediaRecorder?.stop();
+    }
+    if (stopStreams) {
+      this._audioStreams.forEach((s) => s.getTracks().forEach((t) => t.stop()));
+    }
+    this._stopTimeTracking();
+    this._recordingTime = 0;
+    this._cleanupAudioAnalysis();
+    this._silenceTime = 0;
+    this._isInSilence = false;
+    this._stopChunkSplitting();
+    this._audioChunks = [];
+    this._currentChunkIndex = 0;
+    this._processingChunk = false;
+    this._isChunkSplit = false;
+    this._lastChunkEnd = null;
+    this._silenceStartForChunking = null;
+    this._pauseStartTime = null;
+    this._totalPausedTime = 0;
+    this._cleanupMixedStream();
+    this._mediaRecorder = null;
+    this._stream = null;
+    this._audioStreams = [];
+    this._mimeType = null;
+    this._timeslice = null;
+    this._onDataAvailableCallback = null;
+    this._onStartCallback = null;
+    this._onPauseCallback = null;
+    this._onResumeCallback = null;
+    this._onStopCallback = null;
+    this._onErrorCallback = null;
+    this._onTimeUpdateCallback = null;
+    this._onSilenceDetectedCallback = null;
+    this._onAudioDetectedCallback = null;
+    this._onChunkProcessedCallback = null;
+  }
+  // ── Private helpers ───────────────────────────────────────────────────────
+  _assertReady() {
+    if (!this._mediaRecorder) {
+      throw new Error("[AudioChunkify] Not initialised. Call create() first.");
+    }
+    return this._mediaRecorder;
+  }
+  _assertCallback(fn) {
+    if (typeof fn !== "function") {
+      throw new TypeError("Callback must be a function.");
+    }
+  }
+  _captureState() {
+    return {
+      wasRecording: this._mediaRecorder?.state === "recording",
+      wasPaused: this._mediaRecorder?.state === "paused"
+    };
+  }
+  _restoreState(wasRecording, wasPaused) {
+    if (wasRecording) {
+      this.start();
+    } else if (wasPaused) {
+      this.start();
+      this.pause();
+    }
+  }
+  _now() {
+    if (this._audioContext?.state === "running") {
+      return this._audioContext.currentTime;
+    }
+    return Date.now() / 1e3;
+  }
+  // ── Time tracking ─────────────────────────────────────────────────────────
+  _startTimeTracking() {
+    this._stopTimeTracking();
+    this._intervalId = setInterval(() => {
+      this._recordingTime++;
+      this._onTimeUpdateCallback?.(this._recordingTime);
+    }, 1e3);
+  }
+  _stopTimeTracking() {
+    if (this._intervalId !== null) {
+      clearInterval(this._intervalId);
+      this._intervalId = null;
+    }
+  }
+  _pauseTimeTracking() {
+    this._stopTimeTracking();
+  }
+  _resumeTimeTracking() {
+    this._startTimeTracking();
+  }
+  // ── Audio analysis ────────────────────────────────────────────────────────
+  _setupAudioAnalysis() {
+    if (!this._stream) return;
+    this._cleanupAudioAnalysis();
+    try {
+      this._audioContext = new AudioContext();
+      this._analyserNode = this._audioContext.createAnalyser();
+      this._analyserNode.fftSize = DEFAULT_AUDIO_CONSTANTS.ANALYSIS_BUFFER_SIZE;
+      this._analyserNode.smoothingTimeConstant = 0.8;
+      this._sourceNode = this._audioContext.createMediaStreamSource(this._stream);
+      this._sourceNode.connect(this._analyserNode);
+    } catch (err) {
+      console.warn("[AudioChunkify] Could not set up audio analysis:", err);
+      this._cleanupAudioAnalysis();
+    }
+  }
+  _cleanupAudioAnalysis() {
+    this._stopSilenceTracking();
+    try {
+      this._sourceNode?.disconnect();
+    } catch {
+    }
+    this._sourceNode = null;
+    try {
+      this._analyserNode?.disconnect();
+    } catch {
+    }
+    this._analyserNode = null;
+    if (this._audioContext && this._audioContext.state !== "closed") {
+      this._audioContext.close().catch(() => {
+      });
+    }
+    this._audioContext = null;
+  }
+  /**
+   * Measures the current audio level in dBFS via time-domain RMS.
+   * Shared by silence events and chunk-splitting logic.
+   */
+  _measureAudioLevelDb() {
+    if (!this._analyserNode) return -Infinity;
+    const data = new Float32Array(this._analyserNode.fftSize);
+    this._analyserNode.getFloatTimeDomainData(data);
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) sum += data[i] * data[i];
+    const rms = Math.sqrt(sum / data.length);
+    return rms > 0 ? 20 * Math.log10(rms) : -Infinity;
+  }
+  _isCurrentlySilent() {
+    if (!this._analyserNode || this._audioContext?.state !== "running") return false;
+    try {
+      return this._measureAudioLevelDb() < this._silenceThreshold;
+    } catch {
+      return false;
+    }
+  }
+  _checkSilence() {
+    if (!this._analyserNode || this._audioContext?.state !== "running") return;
+    try {
+      const isSilent = this._isCurrentlySilent();
+      if (isSilent && !this._isInSilence) {
+        this._isInSilence = true;
+        if (!this._silenceIntervalId) {
+          this._silenceIntervalId = setInterval(() => {
+            if (this._isInSilence) this._silenceTime++;
+          }, 1e3);
+        }
+        this._onSilenceDetectedCallback?.();
+      } else if (!isSilent && this._isInSilence) {
+        this._isInSilence = false;
+        if (this._silenceIntervalId !== null) {
+          clearInterval(this._silenceIntervalId);
+          this._silenceIntervalId = null;
+        }
+        this._silenceTime = 0;
+        this._onAudioDetectedCallback?.();
+      }
+    } catch (err) {
+      console.warn("[AudioChunkify] Silence check error:", err);
+    }
+  }
+  _startSilenceChecking() {
+    if (this._silenceCheckIntervalId !== null) {
+      clearInterval(this._silenceCheckIntervalId);
+    }
+    this._silenceCheckIntervalId = setInterval(() => this._checkSilence(), 100);
+  }
+  _stopSilenceTracking() {
+    if (this._silenceIntervalId !== null) {
+      clearInterval(this._silenceIntervalId);
+      this._silenceIntervalId = null;
+    }
+    if (this._silenceCheckIntervalId !== null) {
+      clearInterval(this._silenceCheckIntervalId);
+      this._silenceCheckIntervalId = null;
+    }
+    this._isInSilence = false;
+  }
+  // ── Chunk splitting ───────────────────────────────────────────────────────
+  _shouldSplitChunk() {
+    if (this._mediaRecorder?.state === "paused") return false;
+    if (this._lastChunkEnd === null) return false;
+    const currentTime = this._now();
+    const elapsed = currentTime - this._lastChunkEnd;
+    if (elapsed >= this._chunkOptions.maxDuration) return true;
+    if (elapsed >= this._chunkOptions.minDuration) {
+      if (this._isCurrentlySilent()) {
+        if (!this._silenceStartForChunking) {
+          this._silenceStartForChunking = currentTime;
+        }
+        if (currentTime - this._silenceStartForChunking >= this._chunkOptions.minSilenceDuration) {
+          return true;
+        }
+      } else {
+        this._silenceStartForChunking = null;
+      }
+    }
+    return false;
+  }
+  _restartRecorderSegment() {
+    if (this._mediaRecorder?.state === "recording" && !this._processingChunk) {
+      this._isChunkSplit = true;
+      this._mediaRecorder.stop();
+    }
+  }
+  _startChunkSplitting() {
+    this._stopChunkSplitting();
+    this._chunkSplitIntervalId = setInterval(() => {
+      if (this._mediaRecorder?.state === "recording" && !this._processingChunk && this._shouldSplitChunk()) {
+        this._restartRecorderSegment();
+      }
+    }, 100);
+  }
+  _stopChunkSplitting() {
+    if (this._chunkSplitIntervalId !== null) {
+      clearInterval(this._chunkSplitIntervalId);
+      this._chunkSplitIntervalId = null;
+    }
+  }
+  // ── Mixed stream ──────────────────────────────────────────────────────────
+  _createMixedStream() {
+    if (!this._audioStreams.length) return new MediaStream();
+    if (this._mixedStreamDestination) this._cleanupMixedStream();
+    try {
+      this._mixedStreamContext = new AudioContext();
+      this._mixedStreamDestination = this._mixedStreamContext.createMediaStreamDestination();
+      this._mixedStreamSourceNodes = [];
+      for (const stream of this._audioStreams) {
+        if (stream.getAudioTracks().length > 0) {
+          const source = this._mixedStreamContext.createMediaStreamSource(stream);
+          const gainNode = this._mixedStreamContext.createGain();
+          gainNode.gain.value = 1;
+          source.connect(gainNode);
+          gainNode.connect(this._mixedStreamDestination);
+          this._mixedStreamSourceNodes.push({ source, gainNode });
+        }
+      }
+      return this._mixedStreamDestination.stream;
+    } catch (err) {
+      console.warn("[AudioChunkify] Could not create mixed stream, falling back:", err);
+      const fallback = new MediaStream();
+      this._audioStreams.forEach(
+        (s) => s.getAudioTracks().forEach((t) => fallback.addTrack(t))
+      );
+      return fallback;
+    }
+  }
+  _recreateMediaRecorder() {
+    this._stream = this._createMixedStream();
+    const opts = {};
+    if (this._mimeType) opts.mimeType = this._mimeType;
+    this._mediaRecorder = new MediaRecorder(this._stream, opts);
+    this._setupEventHandlers();
+    this._setupAudioAnalysis();
+  }
+  _cleanupMixedStream() {
+    for (const { source, gainNode } of this._mixedStreamSourceNodes) {
+      try {
+        gainNode.disconnect();
+      } catch {
+      }
+      try {
+        source.disconnect();
+      } catch {
+      }
+    }
+    this._mixedStreamSourceNodes = [];
+    try {
+      this._mixedStreamDestination?.stream.getTracks().forEach((t) => t.stop());
+    } catch {
+    }
+    this._mixedStreamDestination = null;
+    if (this._mixedStreamContext?.state !== "closed") {
+      this._mixedStreamContext?.close().catch(() => {
+      });
+    }
+    this._mixedStreamContext = null;
+  }
+  // ── Event wiring ──────────────────────────────────────────────────────────
+  _setupEventHandlers() {
+    if (!this._mediaRecorder) return;
+    this._mediaRecorder.ondataavailable = (event) => {
+      if (event.data?.size > 0) {
+        this._audioChunks.push(event.data);
+        this._onDataAvailableCallback?.(event);
+      }
+    };
+    this._mediaRecorder.onstart = () => {
+      this._startTimeTracking();
+      if (this._audioContext?.state === "suspended") {
+        this._audioContext.resume();
+      }
+      this._startSilenceChecking();
+      if (this._lastChunkEnd === null) {
+        this._lastChunkEnd = this._now();
+      }
+      this._audioChunks = [];
+      this._silenceStartForChunking = null;
+      this._startChunkSplitting();
+      this._onStartCallback?.();
+    };
+    this._mediaRecorder.onpause = () => {
+      this._pauseTimeTracking();
+      this._stopSilenceTracking();
+      this._stopChunkSplitting();
+      this._pauseStartTime = this._now();
+      this._onPauseCallback?.();
+    };
+    this._mediaRecorder.onresume = () => {
+      this._resumeTimeTracking();
+      if (this._audioContext?.state === "suspended") {
+        this._audioContext.resume();
+      }
+      if (this._pauseStartTime !== null) {
+        const pausedDuration = this._now() - this._pauseStartTime;
+        this._totalPausedTime += pausedDuration;
+        if (this._lastChunkEnd !== null) {
+          this._lastChunkEnd += pausedDuration;
+        }
+        this._pauseStartTime = null;
+      }
+      this._startSilenceChecking();
+      this._startChunkSplitting();
+      this._onResumeCallback?.();
+    };
+    this._mediaRecorder.onstop = async () => {
+      this._stopTimeTracking();
+      this._stopSilenceTracking();
+      this._stopChunkSplitting();
+      if (this._isChunkSplit) {
+        await this._processChunk(false);
+        this._audioChunks = [];
+        this._silenceStartForChunking = null;
+        const opts = {};
+        if (this._mimeType) opts.mimeType = this._mimeType;
+        this._mediaRecorder = new MediaRecorder(this._stream, opts);
+        this._setupEventHandlers();
+        this._isChunkSplit = false;
+        if (this._timeslice !== null) {
+          this._mediaRecorder.start(this._timeslice);
+        } else {
+          this._mediaRecorder.start();
+        }
+      } else {
+        await this._processChunk(true);
+        this.resetRecordingTime();
+        this._silenceTime = 0;
+        this._audioChunks = [];
+        this._currentChunkIndex = 0;
+        this._lastChunkEnd = null;
+        this._silenceStartForChunking = null;
+        this._pauseStartTime = null;
+        this._totalPausedTime = 0;
+        this._onStopCallback?.();
+      }
+    };
+    if (this._onErrorCallback) {
+      this._mediaRecorder.onerror = this._onErrorCallback;
+    }
+  }
+  async _processChunk(isLastChunk) {
+    if (!this._audioChunks.length || !this._onChunkProcessedCallback || this._processingChunk) return;
+    this._processingChunk = true;
+    try {
+      const mimeType = this._mimeType ?? getCompatibleMimeType() ?? "audio/webm";
+      const ext = getFileExtensionFromMimeType(mimeType);
+      const now = this._now();
+      let pausedCompensation = 0;
+      if (this._pauseStartTime !== null) {
+        pausedCompensation = now - this._pauseStartTime;
+      }
+      const duration = this._lastChunkEnd !== null ? now - this._lastChunkEnd - pausedCompensation : 0;
+      const index = this._currentChunkIndex;
+      const blob = new Blob(this._audioChunks, { type: mimeType });
+      const file = new File([blob], `chunk-${index}.${ext}`, { type: mimeType });
+      await this._onChunkProcessedCallback({ file, index, duration, isLastChunk });
+      if (!isLastChunk) {
+        this._currentChunkIndex = index + 1;
+        this._lastChunkEnd = this._now();
+        this._totalPausedTime = 0;
+      }
+    } catch (err) {
+      console.error("[AudioChunkify] Error processing chunk:", err);
+    } finally {
+      this._processingChunk = false;
+    }
+  }
+};
+
+export { AudioChunkify, DEFAULT_AUDIO_CONSTANTS, getCompatibleMimeType, getFileExtensionFromMimeType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map