web-audio-recorder-ts 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,770 @@
+'use strict';
+
+/**
+ * Tipos e interfaces principais para WebAudioRecorder
+ */
+/**
+ * Formatos de áudio suportados
+ */
+exports.AudioFormat = void 0;
+(function (AudioFormat) {
+    AudioFormat["WAV"] = "wav";
+    AudioFormat["OGG"] = "ogg";
+    AudioFormat["MP3"] = "mp3";
+})(exports.AudioFormat || (exports.AudioFormat = {}));
+/**
+ * Status do recorder
+ */
+exports.RecorderStatus = void 0;
+(function (RecorderStatus) {
+    RecorderStatus["INACTIVE"] = "inactive";
+    RecorderStatus["RECORDING"] = "recording";
+    RecorderStatus["PAUSED"] = "paused";
+    RecorderStatus["PROCESSING"] = "processing";
+    RecorderStatus["COMPLETE"] = "complete";
+    RecorderStatus["ERROR"] = "error";
+})(exports.RecorderStatus || (exports.RecorderStatus = {}));
+
+/**
+ * Classe base WebAudioRecorder para gravação de áudio
+ *
+ * @module core/WebAudioRecorder
+ */
+/**
+ * Classe principal para gravação de áudio usando Web Audio API
+ */
+class WebAudioRecorder {
+    /**
+     * Cria uma instância do WebAudioRecorder
+     *
+     * @param audioContext - Contexto de áudio Web Audio API
+     * @param encoder - Encoder de áudio a ser usado
+     * @param options - Opções de configuração do recorder
+     */
+    constructor(audioContext, encoder, options = {}) {
+        this.audioContext = null;
+        this.sourceNode = null;
+        this.scriptProcessor = null;
+        this.encoder = null;
+        this.stream = null;
+        this.status = exports.RecorderStatus.INACTIVE;
+        this.sampleRate = 44100;
+        this.numChannels = 2;
+        this.bufferSize = 4096;
+        this.startTime = 0;
+        this.onDataAvailableCallback = null;
+        this.onCompleteCallback = null;
+        this.onErrorCallback = null;
+        this.audioContext = audioContext;
+        this.encoder = encoder;
+        this.sampleRate = options.sampleRate || this.audioContext.sampleRate;
+        this.numChannels = options.numChannels || 2;
+        this.bufferSize = options.bufferSize || 4096;
+        this.onDataAvailableCallback = options.onDataAvailable || null;
+        this.onCompleteCallback = options.onComplete || null;
+        this.onErrorCallback = options.onError || null;
+    }
+    /**
+     * Inicia a gravação de áudio
+     *
+     * @param stream - Stream de mídia a ser gravado
+     * @returns Promise que resolve quando a gravação inicia
+     */
+    async start(stream) {
+        if (this.status === exports.RecorderStatus.RECORDING) {
+            throw new Error('Recording is already in progress');
+        }
+        if (this.status === exports.RecorderStatus.PROCESSING) {
+            throw new Error('Previous recording is still being processed');
+        }
+        try {
+            this.stream = stream;
+            this.status = exports.RecorderStatus.RECORDING;
+            this.startTime = Date.now();
+            if (!this.audioContext) {
+                throw new Error('AudioContext is not initialized');
+            }
+            // Criar source node a partir do stream
+            this.sourceNode = this.audioContext.createMediaStreamSource(stream);
+            // Criar script processor para capturar dados de áudio
+            this.scriptProcessor = this.audioContext.createScriptProcessor(this.bufferSize, this.numChannels, this.numChannels);
+            // Conectar os nós
+            this.sourceNode.connect(this.scriptProcessor);
+            this.scriptProcessor.connect(this.audioContext.destination);
+            // Configurar callback para processar dados de áudio
+            this.scriptProcessor.onaudioprocess = (event) => {
+                if (this.status !== exports.RecorderStatus.RECORDING) {
+                    return;
+                }
+                try {
+                    const inputBuffer = event.inputBuffer;
+                    const buffers = [];
+                    // Extrair dados de cada canal
+                    for (let channel = 0; channel < this.numChannels; channel++) {
+                        const channelData = inputBuffer.getChannelData(channel);
+                        buffers.push(new Float32Array(channelData));
+                    }
+                    // Codificar os dados
+                    if (this.encoder) {
+                        this.encoder.encode(buffers);
+                    }
+                }
+                catch (error) {
+                    this.handleError(error);
+                }
+            };
+        }
+        catch (error) {
+            this.status = exports.RecorderStatus.ERROR;
+            this.handleError(error);
+            throw error;
+        }
+    }
+    /**
+     * Para a gravação e finaliza o arquivo de áudio
+     *
+     * @param mimeType - Tipo MIME do arquivo (padrão: baseado no encoder)
+     * @returns Promise que resolve com o Blob do áudio gravado
+     */
+    async stop(mimeType) {
+        if (this.status !== exports.RecorderStatus.RECORDING) {
+            throw new Error('No recording in progress');
+        }
+        this.status = exports.RecorderStatus.PROCESSING;
+        try {
+            // Desconectar nós
+            if (this.scriptProcessor) {
+                this.scriptProcessor.disconnect();
+                this.scriptProcessor.onaudioprocess = null;
+                this.scriptProcessor = null;
+            }
+            if (this.sourceNode) {
+                this.sourceNode.disconnect();
+                this.sourceNode = null;
+            }
+            // Finalizar encoding
+            if (!this.encoder) {
+                throw new Error('Encoder is not initialized');
+            }
+            const blob = this.encoder.finish(mimeType);
+            const url = URL.createObjectURL(blob);
+            const timecode = Date.now() - this.startTime;
+            // Criar evento de conclusão
+            const completeEvent = {
+                blob,
+                url
+            };
+            this.status = exports.RecorderStatus.COMPLETE;
+            // Chamar callback de conclusão
+            if (this.onCompleteCallback) {
+                this.onCompleteCallback(completeEvent);
+            }
+            // Criar evento de dados disponíveis
+            const dataEvent = {
+                data: blob,
+                timecode
+            };
+            if (this.onDataAvailableCallback) {
+                this.onDataAvailableCallback(dataEvent);
+            }
+            return blob;
+        }
+        catch (error) {
+            this.status = exports.RecorderStatus.ERROR;
+            this.handleError(error);
+            throw error;
+        }
+    }
+    /**
+     * Cancela a gravação atual
+     */
+    cancel() {
+        if (this.status === exports.RecorderStatus.INACTIVE || this.status === exports.RecorderStatus.COMPLETE) {
+            return;
+        }
+        // Desconectar nós
+        if (this.scriptProcessor) {
+            this.scriptProcessor.disconnect();
+            this.scriptProcessor.onaudioprocess = null;
+            this.scriptProcessor = null;
+        }
+        if (this.sourceNode) {
+            this.sourceNode.disconnect();
+            this.sourceNode = null;
+        }
+        // Cancelar encoding
+        if (this.encoder) {
+            this.encoder.cancel();
+        }
+        // Limpar stream
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        this.status = exports.RecorderStatus.INACTIVE;
+    }
+    /**
+     * Obtém o status atual do recorder
+     *
+     * @returns Status atual
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Define callback para quando dados estão disponíveis
+     *
+     * @param callback - Função callback
+     */
+    setOnDataAvailable(callback) {
+        this.onDataAvailableCallback = callback;
+    }
+    /**
+     * Define callback para quando gravação é completada
+     *
+     * @param callback - Função callback
+     */
+    setOnComplete(callback) {
+        this.onCompleteCallback = callback;
+    }
+    /**
+     * Define callback para quando ocorre erro
+     *
+     * @param callback - Função callback
+     */
+    setOnError(callback) {
+        this.onErrorCallback = callback;
+    }
+    /**
+     * Trata erros e chama callback de erro
+     *
+     * @param error - Erro ocorrido
+     */
+    handleError(error) {
+        const errorEvent = {
+            message: error.message,
+            error
+        };
+        if (this.onErrorCallback) {
+            this.onErrorCallback(errorEvent);
+        }
+    }
+    /**
+     * Limpa recursos e reseta o recorder
+     */
+    cleanup() {
+        this.cancel();
+        this.encoder = null;
+        this.audioContext = null;
+        this.status = exports.RecorderStatus.INACTIVE;
+    }
+}
+
+/**
+ * Encoder WAV para áudio
+ *
+ * @module encoders/WavAudioEncoder
+ */
+/**
+ * Encoder WAV simples que cria arquivos WAV a partir de buffers de áudio
+ */
+class WavAudioEncoder {
+    /**
+     * Cria uma instância do encoder WAV
+     *
+     * @param sampleRate - Taxa de amostragem em Hz
+     * @param numChannels - Número de canais (1 = mono, 2 = estéreo)
+     */
+    constructor(sampleRate, numChannels) {
+        this.buffers = [];
+        this.sampleRate = sampleRate;
+        this.numChannels = numChannels;
+        this.buffers = [];
+    }
+    /**
+     * Codifica buffers de áudio
+     *
+     * @param buffers - Array de buffers Float32Array, um por canal
+     */
+    encode(buffers) {
+        if (buffers.length !== this.numChannels) {
+            throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
+        }
+        // Armazenar buffers para processamento posterior
+        this.buffers.push(buffers.map(buffer => new Float32Array(buffer)));
+    }
+    /**
+     * Finaliza o encoding e retorna o Blob WAV
+     *
+     * @param mimeType - Tipo MIME (padrão: 'audio/wav')
+     * @returns Blob contendo o arquivo WAV
+     */
+    finish(mimeType = 'audio/wav') {
+        if (this.buffers.length === 0) {
+            throw new Error('No audio data to encode');
+        }
+        // Calcular tamanho total somando todos os frames de todos os buffers
+        let totalFrames = 0;
+        for (let i = 0; i < this.buffers.length; i++) {
+            if (this.buffers[i].length > 0 && this.buffers[i][0].length > 0) {
+                totalFrames += this.buffers[i][0].length;
+            }
+        }
+        if (totalFrames === 0) {
+            throw new Error('No valid audio data to encode');
+        }
+        // Calcular tamanho dos dados (16-bit samples = 2 bytes por sample)
+        const dataSize = totalFrames * this.numChannels * 2;
+        const fileSize = 44 + dataSize; // 44 bytes de cabeçalho + dados
+        // Criar buffer para o arquivo WAV
+        const buffer = new ArrayBuffer(fileSize);
+        const view = new DataView(buffer);
+        // Escrever cabeçalho WAV
+        // RIFF header
+        this.writeString(view, 0, 'RIFF');
+        view.setUint32(4, fileSize - 8, true); // Tamanho do arquivo - 8 bytes do header RIFF
+        this.writeString(view, 8, 'WAVE');
+        // fmt chunk
+        this.writeString(view, 12, 'fmt ');
+        view.setUint32(16, 16, true); // fmt chunk size
+        view.setUint16(20, 1, true); // audio format (1 = PCM)
+        view.setUint16(22, this.numChannels, true);
+        view.setUint32(24, this.sampleRate, true);
+        view.setUint32(28, this.sampleRate * this.numChannels * 2, true); // byte rate
+        view.setUint16(32, this.numChannels * 2, true); // block align
+        view.setUint16(34, 16, true); // bits per sample
+        // data chunk
+        this.writeString(view, 36, 'data');
+        view.setUint32(40, dataSize, true);
+        // Escrever dados de áudio (intercalados para estéreo)
+        let offset = 44;
+        for (let i = 0; i < this.buffers.length; i++) {
+            const frameBuffers = this.buffers[i];
+            // Verificar se há dados válidos
+            if (frameBuffers.length === 0 || frameBuffers[0].length === 0) {
+                continue;
+            }
+            const frameLength = frameBuffers[0].length;
+            // Verificar se todos os canais têm o mesmo tamanho
+            for (let channel = 0; channel < this.numChannels; channel++) {
+                if (frameBuffers[channel].length !== frameLength) {
+                    throw new Error(`Channel ${channel} has different length in frame ${i}`);
+                }
+            }
+            for (let j = 0; j < frameLength; j++) {
+                for (let channel = 0; channel < this.numChannels; channel++) {
+                    // Verificar se o offset está dentro dos limites
+                    if (offset + 2 > buffer.byteLength) {
+                        throw new Error(`Offset ${offset + 2} exceeds buffer size ${buffer.byteLength}`);
+                    }
+                    // Converter float32 (-1.0 a 1.0) para int16 (-32768 a 32767)
+                    const sample = Math.max(-1, Math.min(1, frameBuffers[channel][j]));
+                    const int16Sample = sample < 0 ? sample * 0x8000 : sample * 0x7FFF;
+                    view.setInt16(offset, int16Sample, true);
+                    offset += 2;
+                }
+            }
+        }
+        // Verificar se escrevemos todos os dados
+        if (offset !== buffer.byteLength) {
+            console.warn(`Warning: Expected to write ${buffer.byteLength} bytes, but wrote ${offset} bytes`);
+        }
+        // Limpar buffers
+        this.buffers = [];
+        return new Blob([buffer], { type: mimeType });
+    }
+    /**
+     * Cancela o encoding e limpa os buffers
+     */
+    cancel() {
+        this.buffers = [];
+    }
+    /**
+     * Escreve string no DataView
+     *
+     * @param view - DataView
+     * @param offset - Offset inicial
+     * @param string - String a escrever
+     */
+    writeString(view, offset, string) {
+        for (let i = 0; i < string.length; i++) {
+            view.setUint8(offset + i, string.charCodeAt(i));
+        }
+    }
+}
+
+/**
+ * Wrapper TypeScript para OggVorbisEncoder (Emscripten)
+ *
+ * @module encoders/OggVorbisEncoder
+ */
+/**
+ * Wrapper para o encoder OGG Vorbis compilado via Emscripten
+ */
+class OggVorbisEncoderWrapper {
+    /**
+     * Cria uma instância do encoder OGG Vorbis
+     *
+     * @param sampleRate - Taxa de amostragem em Hz
+     * @param numChannels - Número de canais
+     * @param options - Opções do encoder OGG
+     */
+    constructor(sampleRate, numChannels, options = {}) {
+        this.encoder = null;
+        this.sampleRate = sampleRate;
+        this.numChannels = numChannels;
+        this.quality = options.quality ?? 0.5;
+        // Verificar se OggVorbisEncoder está disponível
+        if (typeof OggVorbisEncoder === 'undefined') {
+            throw new Error('OggVorbisEncoder is not loaded. Make sure to load OggVorbisEncoder.min.js before using this encoder.');
+        }
+        // Criar instância do encoder
+        this.encoder = new OggVorbisEncoder(sampleRate, numChannels, this.quality);
+    }
+    /**
+     * Codifica buffers de áudio
+     *
+     * @param buffers - Array de buffers Float32Array, um por canal
+     */
+    encode(buffers) {
+        if (!this.encoder) {
+            throw new Error('Encoder is not initialized');
+        }
+        if (buffers.length !== this.numChannels) {
+            throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
+        }
+        this.encoder.encode(buffers);
+    }
+    /**
+     * Finaliza o encoding e retorna o Blob OGG
+     *
+     * @param mimeType - Tipo MIME (padrão: 'audio/ogg')
+     * @returns Blob contendo o arquivo OGG
+     */
+    finish(mimeType = 'audio/ogg') {
+        if (!this.encoder) {
+            throw new Error('Encoder is not initialized');
+        }
+        return this.encoder.finish(mimeType);
+    }
+    /**
+     * Cancela o encoding
+     */
+    cancel() {
+        if (this.encoder) {
+            this.encoder.cancel();
+            this.encoder = null;
+        }
+    }
+}
+/**
+ * Função helper para carregar o script OggVorbisEncoder
+ *
+ * @param scriptUrl - URL do script OggVorbisEncoder.min.js
+ * @returns Promise que resolve quando o script é carregado
+ */
+function loadOggVorbisEncoder(scriptUrl) {
+    return new Promise((resolve, reject) => {
+        // Verificar se já está carregado
+        if (typeof window.OggVorbisEncoder !== 'undefined') {
+            resolve();
+            return;
+        }
+        // Verificar se o script já está sendo carregado
+        const existingScript = document.querySelector(`script[src="${scriptUrl}"]`);
+        if (existingScript) {
+            // Se já está carregado, verificar imediatamente
+            if (typeof window.OggVorbisEncoder !== 'undefined') {
+                resolve();
+                return;
+            }
+            // Aguardar o script existente carregar
+            existingScript.addEventListener('load', () => {
+                setTimeout(() => {
+                    if (typeof window.OggVorbisEncoder !== 'undefined') {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('OggVorbisEncoder failed to load'));
+                    }
+                }, 100);
+            });
+            existingScript.addEventListener('error', () => {
+                reject(new Error('Failed to load OggVorbisEncoder script'));
+            });
+            return;
+        }
+        // Primeiro, verificar se o arquivo existe fazendo uma requisição HEAD
+        fetch(scriptUrl, { method: 'HEAD', cache: 'no-cache' })
+            .then(response => {
+            if (!response.ok) {
+                throw new Error(`File not found: ${scriptUrl} (${response.status})`);
+            }
+            // Criar e carregar novo script
+            const script = document.createElement('script');
+            script.src = scriptUrl;
+            script.async = false; // Carregar de forma síncrona para garantir ordem
+            script.type = 'text/javascript';
+            script.onload = () => {
+                // Aguardar um pouco para garantir que o objeto global foi criado
+                setTimeout(() => {
+                    if (typeof window.OggVorbisEncoder !== 'undefined') {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('OggVorbisEncoder object not found after script load. The script may not have exported the global correctly.'));
+                    }
+                }, 200);
+            };
+            script.onerror = (event) => {
+                const error = new Error(`Failed to load OggVorbisEncoder script from ${scriptUrl}. Check browser console for CORS or network errors.`);
+                console.error('Script load error:', event);
+                console.error('Script URL:', scriptUrl);
+                reject(error);
+            };
+            document.head.appendChild(script);
+        })
+            .catch(error => {
+            reject(new Error(`Cannot access OggVorbisEncoder script at ${scriptUrl}: ${error.message}`));
+        });
+    });
+}
+
+/**
+ * Wrapper TypeScript para Mp3LameEncoder (Emscripten)
+ *
+ * @module encoders/Mp3LameEncoder
+ */
+/**
+ * Wrapper para o encoder MP3 LAME compilado via Emscripten
+ */
+class Mp3LameEncoderWrapper {
+    /**
+     * Cria uma instância do encoder MP3 LAME
+     *
+     * @param sampleRate - Taxa de amostragem em Hz
+     * @param numChannels - Número de canais
+     * @param options - Opções do encoder MP3
+     */
+    constructor(sampleRate, numChannels, options = {}) {
+        this.encoder = null;
+        this.sampleRate = sampleRate;
+        this.numChannels = numChannels;
+        this.bitrate = options.bitrate ?? 128;
+        // Verificar se Mp3LameEncoder está disponível
+        if (typeof Mp3LameEncoder === 'undefined') {
+            throw new Error('Mp3LameEncoder is not loaded. Make sure to load Mp3LameEncoder.min.js before using this encoder.');
+        }
+        // Criar instância do encoder
+        this.encoder = new Mp3LameEncoder(sampleRate, numChannels, this.bitrate);
+    }
+    /**
+     * Codifica buffers de áudio
+     *
+     * @param buffers - Array de buffers Float32Array, um por canal
+     */
+    encode(buffers) {
+        if (!this.encoder) {
+            throw new Error('Encoder is not initialized');
+        }
+        if (buffers.length !== this.numChannels) {
+            throw new Error(`Expected ${this.numChannels} channels, got ${buffers.length}`);
+        }
+        this.encoder.encode(buffers);
+    }
+    /**
+     * Finaliza o encoding e retorna o Blob MP3
+     *
+     * @param mimeType - Tipo MIME (padrão: 'audio/mpeg')
+     * @returns Blob contendo o arquivo MP3
+     */
+    finish(mimeType = 'audio/mpeg') {
+        if (!this.encoder) {
+            throw new Error('Encoder is not initialized');
+        }
+        return this.encoder.finish(mimeType);
+    }
+    /**
+     * Cancela o encoding
+     */
+    cancel() {
+        if (this.encoder) {
+            this.encoder.cancel();
+            this.encoder = null;
+        }
+    }
+}
+/**
+ * Função helper para carregar o script Mp3LameEncoder
+ *
+ * @param scriptUrl - URL do script Mp3LameEncoder.min.js
+ * @returns Promise que resolve quando o script é carregado
+ */
+function loadMp3LameEncoder(scriptUrl) {
+    return new Promise((resolve, reject) => {
+        // Verificar se já está carregado
+        if (typeof window.Mp3LameEncoder !== 'undefined') {
+            resolve();
+            return;
+        }
+        // Verificar se o script já está sendo carregado
+        const existingScript = document.querySelector(`script[src="${scriptUrl}"]`);
+        if (existingScript) {
+            // Se já está carregado, verificar imediatamente
+            if (typeof window.Mp3LameEncoder !== 'undefined') {
+                resolve();
+                return;
+            }
+            // Aguardar o script existente carregar
+            existingScript.addEventListener('load', () => {
+                setTimeout(() => {
+                    if (typeof window.Mp3LameEncoder !== 'undefined') {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Mp3LameEncoder failed to load'));
+                    }
+                }, 100);
+            });
+            existingScript.addEventListener('error', () => {
+                reject(new Error('Failed to load Mp3LameEncoder script'));
+            });
+            return;
+        }
+        // Primeiro, verificar se o arquivo existe fazendo uma requisição HEAD
+        fetch(scriptUrl, { method: 'HEAD', cache: 'no-cache' })
+            .then(response => {
+            if (!response.ok) {
+                throw new Error(`File not found: ${scriptUrl} (${response.status})`);
+            }
+            // Criar e carregar novo script
+            const script = document.createElement('script');
+            script.src = scriptUrl;
+            script.async = false; // Carregar de forma síncrona para garantir ordem
+            script.type = 'text/javascript';
+            script.onload = () => {
+                // Aguardar um pouco para garantir que o objeto global foi criado
+                setTimeout(() => {
+                    if (typeof window.Mp3LameEncoder !== 'undefined') {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Mp3LameEncoder object not found after script load. The script may not have exported the global correctly.'));
+                    }
+                }, 200);
+            };
+            script.onerror = (event) => {
+                const error = new Error(`Failed to load Mp3LameEncoder script from ${scriptUrl}. Check browser console for CORS or network errors.`);
+                console.error('Script load error:', event);
+                console.error('Script URL:', scriptUrl);
+                reject(error);
+            };
+            document.head.appendChild(script);
+        })
+            .catch(error => {
+            reject(new Error(`Cannot access Mp3LameEncoder script at ${scriptUrl}: ${error.message}`));
+        });
+    });
+}
+
+/**
+ * Recorder WAV usando WebAudioRecorder
+ *
+ * @module recorders/WebAudioRecorderWav
+ */
+/**
+ * Classe para gravação de áudio em formato WAV
+ */
+class WebAudioRecorderWav extends WebAudioRecorder {
+    /**
+     * Cria uma instância do recorder WAV
+     *
+     * @param audioContext - Contexto de áudio Web Audio API
+     * @param options - Opções de configuração do recorder
+     */
+    constructor(audioContext, options = {}) {
+        const sampleRate = options.sampleRate || audioContext.sampleRate;
+        const numChannels = options.numChannels || 2;
+        const encoder = new WavAudioEncoder(sampleRate, numChannels);
+        super(audioContext, encoder, options);
+    }
+}
+
+/**
+ * Recorder OGG Vorbis usando WebAudioRecorder
+ *
+ * @module recorders/WebAudioRecorderOgg
+ */
+/**
+ * Classe para gravação de áudio em formato OGG Vorbis
+ */
+class WebAudioRecorderOgg extends WebAudioRecorder {
+    /**
+     * Cria uma instância do recorder OGG Vorbis
+     *
+     * @param audioContext - Contexto de áudio Web Audio API
+     * @param options - Opções de configuração do recorder
+     * @param oggOptions - Opções específicas do encoder OGG
+     */
+    constructor(audioContext, options = {}, oggOptions = {}) {
+        const sampleRate = options.sampleRate || audioContext.sampleRate;
+        const numChannels = options.numChannels || 2;
+        const encoder = new OggVorbisEncoderWrapper(sampleRate, numChannels, oggOptions);
+        super(audioContext, encoder, options);
+        this.oggOptions = oggOptions;
+    }
+    /**
+     * Carrega o script OggVorbisEncoder antes de usar
+     *
+     * @param scriptUrl - URL do script OggVorbisEncoder.min.js
+     * @returns Promise que resolve quando o script é carregado
+     */
+    static async loadEncoder(scriptUrl) {
+        return loadOggVorbisEncoder(scriptUrl);
+    }
+}
+
+/**
+ * Recorder MP3 usando WebAudioRecorder
+ *
+ * @module recorders/WebAudioRecorderMp3
+ */
+/**
+ * Classe para gravação de áudio em formato MP3
+ */
+class WebAudioRecorderMp3 extends WebAudioRecorder {
+    /**
+     * Cria uma instância do recorder MP3
+     *
+     * @param audioContext - Contexto de áudio Web Audio API
+     * @param options - Opções de configuração do recorder
+     * @param mp3Options - Opções específicas do encoder MP3
+     */
+    constructor(audioContext, options = {}, mp3Options = {}) {
+        const sampleRate = options.sampleRate || audioContext.sampleRate;
+        const numChannels = options.numChannels || 2;
+        const encoder = new Mp3LameEncoderWrapper(sampleRate, numChannels, mp3Options);
+        super(audioContext, encoder, options);
+        this.mp3Options = mp3Options;
+    }
+    /**
+     * Carrega o script Mp3LameEncoder antes de usar
+     *
+     * @param scriptUrl - URL do script Mp3LameEncoder.min.js
+     * @returns Promise que resolve quando o script é carregado
+     */
+    static async loadEncoder(scriptUrl) {
+        return loadMp3LameEncoder(scriptUrl);
+    }
+}
+
+exports.Mp3LameEncoderWrapper = Mp3LameEncoderWrapper;
+exports.OggVorbisEncoderWrapper = OggVorbisEncoderWrapper;
+exports.WavAudioEncoder = WavAudioEncoder;
+exports.WebAudioRecorder = WebAudioRecorder;
+exports.WebAudioRecorderMp3 = WebAudioRecorderMp3;
+exports.WebAudioRecorderOgg = WebAudioRecorderOgg;
+exports.WebAudioRecorderWav = WebAudioRecorderWav;
+exports.loadMp3LameEncoder = loadMp3LameEncoder;
+exports.loadOggVorbisEncoder = loadOggVorbisEncoder;
+//# sourceMappingURL=index.cjs.js.map