web-audio-recorder-ts 1.0.0

package/dist/index.umd.js

@@ -0,0 +1,776 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WebAudioRecorder = {}));
+})(this, (function (exports) { '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.umd.js.map