@siteed/expo-audio-stream 1.4.0 → 1.5.1

package/build/workers/InlineFeaturesExtractor.web.js

@@ -1,311 +0,0 @@
-export const InlineFeaturesExtractor = `
-// Unique ID counter
-let uniqueIdCounter = 0
-
-self.onmessage = function (event) {
-    const {
-        channelData, // this is only the newly recorded data when live recording.
-        sampleRate,
-        pointsPerSecond,
-        algorithm,
-        bitDepth,
-        fullAudioDurationMs,
-        numberOfChannels,
-        features: _features,
-    } = event.data
-    const features = _features || {}
-
-    const SILENCE_THRESHOLD = 0.01
-    const MIN_SILENCE_DURATION = 1.5 * sampleRate // 1.5 seconds of silence
-    const SPEECH_INERTIA_DURATION = 0.1 * sampleRate // Speech inertia duration in samples
-    const RMS_THRESHOLD = 0.01
-    const ZCR_THRESHOLD = 0.1
-
-    // Placeholder functions for feature extraction
-    const extractMFCC = (segmentData, sampleRate) => {
-        // Implement MFCC extraction logic here
-        return []
-    }
-
-    const extractSpectralCentroid = (segmentData, sampleRate) => {
-        const magnitudeSpectrum = segmentData.map((v) => v * v)
-        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)
-        if (sum === 0) return 0
-
-        const weightedSum = magnitudeSpectrum.reduce(
-            (acc, value, index) => acc + index * value,
-            0
-        )
-        return (
-            ((weightedSum / sum) * (sampleRate / 2)) / magnitudeSpectrum.length
-        )
-    }
-
-    const extractSpectralFlatness = (segmentData) => {
-        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))
-        const geometricMean = Math.exp(
-            magnitudeSpectrum
-                .map((v) => Math.log(v + Number.MIN_VALUE))
-                .reduce((a, b) => a + b) / magnitudeSpectrum.length
-        )
-        const arithmeticMean =
-            magnitudeSpectrum.reduce((a, b) => a + b) / magnitudeSpectrum.length
-        return arithmeticMean === 0 ? 0 : geometricMean / arithmeticMean
-    }
-
-    const extractSpectralRollOff = (segmentData, sampleRate) => {
-        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))
-        const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0)
-        const rollOffThreshold = totalEnergy * 0.85
-        let cumulativeEnergy = 0
-
-        for (let i = 0; i < magnitudeSpectrum.length; i++) {
-            cumulativeEnergy += magnitudeSpectrum[i]
-            if (cumulativeEnergy >= rollOffThreshold) {
-                return (i / magnitudeSpectrum.length) * (sampleRate / 2)
-            }
-        }
-
-        return 0
-    }
-
-    const extractSpectralBandwidth = (segmentData, sampleRate) => {
-        const centroid = extractSpectralCentroid(segmentData, sampleRate)
-        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))
-        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)
-        if (sum === 0) return 0
-
-        const weightedSum = magnitudeSpectrum.reduce(
-            (acc, value, index) => acc + value * Math.pow(index - centroid, 2),
-            0
-        )
-        return Math.sqrt(weightedSum / sum)
-    }
-
-    const extractChromagram = (segmentData, sampleRate) => {
-        return [] // TODO implement
-    }
-
-    const extractHNR = (segmentData) => {
-        const frameSize = segmentData.length
-        const autocorrelation = new Float32Array(frameSize)
-
-        // Compute the autocorrelation of the segment data
-        for (let i = 0; i < frameSize; i++) {
-            let sum = 0
-            for (let j = 0; j < frameSize - i; j++) {
-                sum += segmentData[j] * segmentData[j + i]
-            }
-            autocorrelation[i] = sum
-        }
-
-        // Find the maximum autocorrelation value (excluding the zero lag)
-        const maxAutocorrelation = Math.max(...autocorrelation.subarray(1))
-
-        // Compute the HNR
-        return autocorrelation[0] !== 0
-            ? 10 *
-                  Math.log10(
-                      maxAutocorrelation /
-                          (autocorrelation[0] - maxAutocorrelation)
-                  )
-            : 0
-    }
-
-    const extractWaveform = (
-        channelData, // Float32Array
-        sampleRate, // number
-        pointsPerSecond, // number
-        algorithm // string
-    ) => {
-        const totalSamples = channelData.length
-        const segmentDuration = totalSamples / sampleRate
-        const totalPoints = Math.max(
-            Math.ceil(segmentDuration * pointsPerSecond),
-            1
-        )
-        const pointInterval = Math.ceil(totalSamples / totalPoints)
-        const dataPoints = []
-        let minAmplitude = Infinity
-        let maxAmplitude = -Infinity
-        let silenceStart = null
-        let lastSpeechEnd = -Infinity
-        let isSpeech = false
-
-        const expectedPoints = segmentDuration * pointsPerSecond
-        const samplesPerPoint = Math.ceil(channelData.length / expectedPoints)
-
-        for (let i = 0; i < expectedPoints; i++) {
-            const start = i * samplesPerPoint
-            const end = Math.min(start + samplesPerPoint, totalSamples)
-
-            let sumSquares = 0
-            let zeroCrossings = 0
-            let prevValue = channelData[start]
-            let localMinAmplitude = Infinity
-            let localMaxAmplitude = -Infinity
-            let hasNonZeroValue = false
-
-            // compute values for the segment
-            for (let j = start; j < end; j++) {
-                const value = channelData[j]
-                sumSquares += value * value
-                if (j > start && value * prevValue < 0) {
-                    zeroCrossings++
-                }
-                prevValue = value
-
-                // We need to keep absolute value otherwise we cannot visualize properly
-                const absValue = Math.abs(value)
-                localMinAmplitude = Math.min(localMinAmplitude, absValue)
-                localMaxAmplitude = Math.max(localMaxAmplitude, absValue)
-
-                if (value !== 0) {
-                    hasNonZeroValue = true
-                }
-            }
-
-            // Post-processing checks
-            if (!hasNonZeroValue) {
-                // All values are zero
-                localMinAmplitude = 0
-                localMaxAmplitude = 0
-            }
-
-            const rms = Math.sqrt(sumSquares / (end - start))
-            minAmplitude = Math.min(minAmplitude, localMinAmplitude)
-            maxAmplitude = Math.max(maxAmplitude, localMaxAmplitude)
-
-            const energy = sumSquares
-            const zcr = zeroCrossings / (end - start)
-
-            const silent = rms < SILENCE_THRESHOLD
-            const dB = 20 * Math.log10(rms)
-
-            if (silent) {
-                if (silenceStart === null) {
-                    silenceStart = start
-                } else if (start - silenceStart > MIN_SILENCE_DURATION) {
-                    // Silence detected for longer than the threshold, set amplitude to 0
-                    localMaxAmplitude = 0
-                    localMinAmplitude = 0
-                    isSpeech = false
-                }
-            } else {
-                silenceStart = null
-                if (
-                    !isSpeech &&
-                    start - lastSpeechEnd < SPEECH_INERTIA_DURATION
-                ) {
-                    isSpeech = true
-                }
-                lastSpeechEnd = end
-            }
-
-            const activeSpeech =
-                (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||
-                (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION)
-
-            if (activeSpeech) {
-                isSpeech = true
-                lastSpeechEnd = end
-            } else {
-                isSpeech = false
-            }
-
-            const bytesPerSample = bitDepth / 8
-            const startPosition = start * bytesPerSample * numberOfChannels // Calculate start position in bytes
-            const endPosition = end * bytesPerSample * numberOfChannels // Calculate end position in bytes
-
-            // Compute features
-            const segmentData = channelData.slice(start, end)
-            const mfcc = features.mfcc
-                ? extractMFCC(segmentData, sampleRate)
-                : []
-            const spectralCentroid = features.spectralCentroid
-                ? extractSpectralCentroid(segmentData, sampleRate)
-                : 0
-            const spectralFlatness = features.spectralFlatness
-                ? extractSpectralFlatness(segmentData)
-                : 0
-            const spectralRollOff = features.spectralRollOff
-                ? extractSpectralRollOff(segmentData, sampleRate)
-                : 0
-            const spectralBandwidth = features.spectralBandwidth
-                ? extractSpectralBandwidth(segmentData, sampleRate)
-                : 0
-            const chromagram = features.chromagram
-                ? extractChromagram(segmentData, sampleRate)
-                : []
-            const hnr = features.hnr ? extractHNR(segmentData) : 0
-
-            const peakAmp = Math.max(Math.abs(localMaxAmplitude), Math.abs(localMinAmplitude))
-            const newData = {
-                id: uniqueIdCounter++, // Assign unique ID and increment the counter
-                amplitude: algorithm === 'peak' ? peakAmp : rms,
-                activeSpeech,
-                dB,
-                silent,
-                features: {
-                    energy,
-                    rms,
-                    minAmplitude: localMinAmplitude,
-                    maxAmplitude: localMaxAmplitude,
-                    zcr,
-                    mfcc: [], // Placeholder for MFCC features
-                    spectralCentroid, // Computed spectral centroid
-                    spectralFlatness, // Computed spectral flatness
-                    spectralRollOff, // Computed spectral roll-off
-                    spectralBandwidth, // Computed spectral bandwidth
-                    chromagram, // Computed chromagram
-                    hnr, // Computed HNR
-                },
-                startTime: start / sampleRate,
-                endTime: end / sampleRate,
-                startPosition,
-                endPosition,
-                samples: end - start,
-                speaker: 0, // Assuming speaker detection is to be handled later
-            }
-
-            dataPoints.push(newData)
-        }
-
-        return {
-            pointsPerSecond,
-            amplitudeAlgorithm: algorithm,
-            durationMs: fullAudioDurationMs,
-            bitDepth,
-            samples: totalSamples,
-            numberOfChannels,
-            sampleRate,
-            dataPoints,
-            amplitudeRange: {
-                min: minAmplitude,
-                max: maxAmplitude,
-            },
-            speakerChanges: [], // Placeholder for future speaker detection logic
-        }
-    }
-
-    try {
-        const result = extractWaveform(
-            channelData,
-            sampleRate,
-            pointsPerSecond,
-            algorithm
-        )
-        self.postMessage({
-            command: 'features',
-            result,
-        })
-    } catch (error) {
-        console.error('[AudioFeaturesExtractor] Error in processing', error)
-        self.postMessage({ error: error.message })
-    } finally {
-        // Do not close the worker so it can be re-used for subsequent messages
-        // self.close();
-    }
-}
-`;
-//# sourceMappingURL=InlineFeaturesExtractor.web.js.map

package/build/workers/InlineFeaturesExtractor.web.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InlineFeaturesExtractor.web.js","sourceRoot":"","sources":["../../src/workers/InlineFeaturesExtractor.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqTtC,CAAA","sourcesContent":["export const InlineFeaturesExtractor = `\n// Unique ID counter\nlet uniqueIdCounter = 0\n\nself.onmessage = function (event) {\n    const {\n        channelData, // this is only the newly recorded data when live recording.\n        sampleRate,\n        pointsPerSecond,\n        algorithm,\n        bitDepth,\n        fullAudioDurationMs,\n        numberOfChannels,\n        features: _features,\n    } = event.data\n    const features = _features || {}\n\n    const SILENCE_THRESHOLD = 0.01\n    const MIN_SILENCE_DURATION = 1.5 * sampleRate // 1.5 seconds of silence\n    const SPEECH_INERTIA_DURATION = 0.1 * sampleRate // Speech inertia duration in samples\n    const RMS_THRESHOLD = 0.01\n    const ZCR_THRESHOLD = 0.1\n\n    // Placeholder functions for feature extraction\n    const extractMFCC = (segmentData, sampleRate) => {\n        // Implement MFCC extraction logic here\n        return []\n    }\n\n    const extractSpectralCentroid = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => v * v)\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + index * value,\n            0\n        )\n        return (\n            ((weightedSum / sum) * (sampleRate / 2)) / magnitudeSpectrum.length\n        )\n    }\n\n    const extractSpectralFlatness = (segmentData) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const geometricMean = Math.exp(\n            magnitudeSpectrum\n                .map((v) => Math.log(v + Number.MIN_VALUE))\n                .reduce((a, b) => a + b) / magnitudeSpectrum.length\n        )\n        const arithmeticMean =\n            magnitudeSpectrum.reduce((a, b) => a + b) / magnitudeSpectrum.length\n        return arithmeticMean === 0 ? 0 : geometricMean / arithmeticMean\n    }\n\n    const extractSpectralRollOff = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        const rollOffThreshold = totalEnergy * 0.85\n        let cumulativeEnergy = 0\n\n        for (let i = 0; i < magnitudeSpectrum.length; i++) {\n            cumulativeEnergy += magnitudeSpectrum[i]\n            if (cumulativeEnergy >= rollOffThreshold) {\n                return (i / magnitudeSpectrum.length) * (sampleRate / 2)\n            }\n        }\n\n        return 0\n    }\n\n    const extractSpectralBandwidth = (segmentData, sampleRate) => {\n        const centroid = extractSpectralCentroid(segmentData, sampleRate)\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + value * Math.pow(index - centroid, 2),\n            0\n        )\n        return Math.sqrt(weightedSum / sum)\n    }\n\n    const extractChromagram = (segmentData, sampleRate) => {\n        return [] // TODO implement\n    }\n\n    const extractHNR = (segmentData) => {\n        const frameSize = segmentData.length\n        const autocorrelation = new Float32Array(frameSize)\n\n        // Compute the autocorrelation of the segment data\n        for (let i = 0; i < frameSize; i++) {\n            let sum = 0\n            for (let j = 0; j < frameSize - i; j++) {\n                sum += segmentData[j] * segmentData[j + i]\n            }\n            autocorrelation[i] = sum\n        }\n\n        // Find the maximum autocorrelation value (excluding the zero lag)\n        const maxAutocorrelation = Math.max(...autocorrelation.subarray(1))\n\n        // Compute the HNR\n        return autocorrelation[0] !== 0\n            ? 10 *\n                  Math.log10(\n                      maxAutocorrelation /\n                          (autocorrelation[0] - maxAutocorrelation)\n                  )\n            : 0\n    }\n\n    const extractWaveform = (\n        channelData, // Float32Array\n        sampleRate, // number\n        pointsPerSecond, // number\n        algorithm // string\n    ) => {\n        const totalSamples = channelData.length\n        const segmentDuration = totalSamples / sampleRate\n        const totalPoints = Math.max(\n            Math.ceil(segmentDuration * pointsPerSecond),\n            1\n        )\n        const pointInterval = Math.ceil(totalSamples / totalPoints)\n        const dataPoints = []\n        let minAmplitude = Infinity\n        let maxAmplitude = -Infinity\n        let silenceStart = null\n        let lastSpeechEnd = -Infinity\n        let isSpeech = false\n\n        const expectedPoints = segmentDuration * pointsPerSecond\n        const samplesPerPoint = Math.ceil(channelData.length / expectedPoints)\n\n        for (let i = 0; i < expectedPoints; i++) {\n            const start = i * samplesPerPoint\n            const end = Math.min(start + samplesPerPoint, totalSamples)\n\n            let sumSquares = 0\n            let zeroCrossings = 0\n            let prevValue = channelData[start]\n            let localMinAmplitude = Infinity\n            let localMaxAmplitude = -Infinity\n            let hasNonZeroValue = false\n\n            // compute values for the segment\n            for (let j = start; j < end; j++) {\n                const value = channelData[j]\n                sumSquares += value * value\n                if (j > start && value * prevValue < 0) {\n                    zeroCrossings++\n                }\n                prevValue = value\n\n                // We need to keep absolute value otherwise we cannot visualize properly\n                const absValue = Math.abs(value)\n                localMinAmplitude = Math.min(localMinAmplitude, absValue)\n                localMaxAmplitude = Math.max(localMaxAmplitude, absValue)\n\n                if (value !== 0) {\n                    hasNonZeroValue = true\n                }\n            }\n\n            // Post-processing checks\n            if (!hasNonZeroValue) {\n                // All values are zero\n                localMinAmplitude = 0\n                localMaxAmplitude = 0\n            }\n\n            const rms = Math.sqrt(sumSquares / (end - start))\n            minAmplitude = Math.min(minAmplitude, localMinAmplitude)\n            maxAmplitude = Math.max(maxAmplitude, localMaxAmplitude)\n\n            const energy = sumSquares\n            const zcr = zeroCrossings / (end - start)\n\n            const silent = rms < SILENCE_THRESHOLD\n            const dB = 20 * Math.log10(rms)\n\n            if (silent) {\n                if (silenceStart === null) {\n                    silenceStart = start\n                } else if (start - silenceStart > MIN_SILENCE_DURATION) {\n                    // Silence detected for longer than the threshold, set amplitude to 0\n                    localMaxAmplitude = 0\n                    localMinAmplitude = 0\n                    isSpeech = false\n                }\n            } else {\n                silenceStart = null\n                if (\n                    !isSpeech &&\n                    start - lastSpeechEnd < SPEECH_INERTIA_DURATION\n                ) {\n                    isSpeech = true\n                }\n                lastSpeechEnd = end\n            }\n\n            const activeSpeech =\n                (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||\n                (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION)\n\n            if (activeSpeech) {\n                isSpeech = true\n                lastSpeechEnd = end\n            } else {\n                isSpeech = false\n            }\n\n            const bytesPerSample = bitDepth / 8\n            const startPosition = start * bytesPerSample * numberOfChannels // Calculate start position in bytes\n            const endPosition = end * bytesPerSample * numberOfChannels // Calculate end position in bytes\n\n            // Compute features\n            const segmentData = channelData.slice(start, end)\n            const mfcc = features.mfcc\n                ? extractMFCC(segmentData, sampleRate)\n                : []\n            const spectralCentroid = features.spectralCentroid\n                ? extractSpectralCentroid(segmentData, sampleRate)\n                : 0\n            const spectralFlatness = features.spectralFlatness\n                ? extractSpectralFlatness(segmentData)\n                : 0\n            const spectralRollOff = features.spectralRollOff\n                ? extractSpectralRollOff(segmentData, sampleRate)\n                : 0\n            const spectralBandwidth = features.spectralBandwidth\n                ? extractSpectralBandwidth(segmentData, sampleRate)\n                : 0\n            const chromagram = features.chromagram\n                ? extractChromagram(segmentData, sampleRate)\n                : []\n            const hnr = features.hnr ? extractHNR(segmentData) : 0\n\n            const peakAmp = Math.max(Math.abs(localMaxAmplitude), Math.abs(localMinAmplitude))\n            const newData = {\n                id: uniqueIdCounter++, // Assign unique ID and increment the counter\n                amplitude: algorithm === 'peak' ? peakAmp : rms,\n                activeSpeech,\n                dB,\n                silent,\n                features: {\n                    energy,\n                    rms,\n                    minAmplitude: localMinAmplitude,\n                    maxAmplitude: localMaxAmplitude,\n                    zcr,\n                    mfcc: [], // Placeholder for MFCC features\n                    spectralCentroid, // Computed spectral centroid\n                    spectralFlatness, // Computed spectral flatness\n                    spectralRollOff, // Computed spectral roll-off\n                    spectralBandwidth, // Computed spectral bandwidth\n                    chromagram, // Computed chromagram\n                    hnr, // Computed HNR\n                },\n                startTime: start / sampleRate,\n                endTime: end / sampleRate,\n                startPosition,\n                endPosition,\n                samples: end - start,\n                speaker: 0, // Assuming speaker detection is to be handled later\n            }\n\n            dataPoints.push(newData)\n        }\n\n        return {\n            pointsPerSecond,\n            amplitudeAlgorithm: algorithm,\n            durationMs: fullAudioDurationMs,\n            bitDepth,\n            samples: totalSamples,\n            numberOfChannels,\n            sampleRate,\n            dataPoints,\n            amplitudeRange: {\n                min: minAmplitude,\n                max: maxAmplitude,\n            },\n            speakerChanges: [], // Placeholder for future speaker detection logic\n        }\n    }\n\n    try {\n        const result = extractWaveform(\n            channelData,\n            sampleRate,\n            pointsPerSecond,\n            algorithm\n        )\n        self.postMessage({\n            command: 'features',\n            result,\n        })\n    } catch (error) {\n        console.error('[AudioFeaturesExtractor] Error in processing', error)\n        self.postMessage({ error: error.message })\n    } finally {\n        // Do not close the worker so it can be re-used for subsequent messages\n        // self.close();\n    }\n}\n`\n"]}

package/build/workers/inlineAudioWebWorker.web.d.ts

@@ -1,2 +0,0 @@
-export declare const InlineAudioWebWorker = "\nconst DEFAULT_BIT_DEPTH = 32\nconst DEFAULT_SAMPLE_RATE = 44100\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n    constructor() {\n        super()\n        this.recordedBuffers = [] // Float32Array\n        this.newRecBuffer = [] // Float32Array\n        this.resampledBuffer = [] // Float32Array\n        this.exportIntervalSamples = 0\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth\n        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten\n        this.numberOfChannels = 1 // Default to 1 channel (mono)\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\n                this.recordSampleRate = event.data.recordSampleRate\n                this.exportSampleRate =\n                    event.data.exportSampleRate || event.data.recordSampleRate\n                this.exportIntervalSamples =\n                    this.recordSampleRate * (event.data.interval / 1000)\n                if (event.data.numberOfChannels) {\n                    this.numberOfChannels = event.data.numberOfChannels\n                }\n                if (event.data.recordBitDepth) {\n                    this.recordBitDepth = event.data.recordBitDepth\n                }\n                this.exportBitDepth =\n                    event.data.exportBitDepth ||\n                    this.recordBitDepth ||\n                    DEFAULT_BIT_DEPTH\n                break\n            case 'stop':\n                this.isRecording = false\n                this.getAllRecordedData()\n                    .then((fullRecordedData) => {\n                        this.port.postMessage({\n                            command: 'recordedData',\n                            recordedData: fullRecordedData,\n                            bitDepth: this.exportBitDepth,\n                            sampleRate: this.exportSampleRate,\n                        })\n                        return fullRecordedData\n                    })\n                    .catch((error) => {\n                        console.error(\n                            'RecorderProcessor Error extracting recorded data:',\n                            error\n                        )\n                    })\n                break\n        }\n    }\n\n    process(inputs, _outputs, _parameters) {\n        if (!this.isRecording) return true\n        const input = inputs[0]\n        if (input.length > 0) {\n            const newBuffer = new Float32Array(input[0])\n            this.newRecBuffer.push(newBuffer)\n            this.recordedBuffers.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.exportNewData()\n                this.samplesSinceLastExport = 0\n            }\n        }\n        return true\n    }\n\n    mergeBuffers(bufferArray, recLength) {\n        const result = new Float32Array(recLength)\n        let offset = 0\n        for (let i = 0; i < bufferArray.length; i++) {\n            result.set(bufferArray[i], offset)\n            offset += bufferArray[i].length\n        }\n        return result\n    }\n\n    floatTo16BitPCM(input) {\n        const output = new Int16Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x8000 : s * 0x7fff\n        }\n        console.debug(\n            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    floatTo32BitPCM(input) {\n        const output = new Int32Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff\n        }\n        console.debug(\n            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            (samples.length * targetSampleRate) / this.recordSampleRate\n        )\n        const ratio = this.recordSampleRate / targetSampleRate\n        let offset = 0\n        for (let i = 0; i < resampledBuffer.length; i++) {\n            const nextOffset = Math.floor((i + 1) * ratio)\n            let accum = 0\n            let count = 0\n            for (let j = offset; j < nextOffset && j < samples.length; j++) {\n                accum += samples[j]\n                count++\n            }\n            resampledBuffer[i] = accum / count\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    async resampleBuffer(buffer, targetSampleRate) {\n        if (typeof OfflineAudioContext === 'undefined') {\n            return this.resample(buffer, targetSampleRate)\n        }\n\n        if (this.recordSampleRate === targetSampleRate) {\n            return buffer\n        }\n        const offlineContext = new OfflineAudioContext(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        const sourceBuffer = offlineContext.createBuffer(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        sourceBuffer.copyToChannel(buffer, 0)\n\n        const bufferSource = offlineContext.createBufferSource()\n        bufferSource.buffer = sourceBuffer\n        bufferSource.connect(offlineContext.destination)\n        bufferSource.start()\n\n        const renderedBuffer = await offlineContext.startRendering()\n\n        const resampledBuffer = new Float32Array(renderedBuffer.length)\n        renderedBuffer.copyFromChannel(resampledBuffer, 0)\n\n        return resampledBuffer\n    }\n\n    async exportNewData() {\n        // Calculate the total length of the new recorded buffers\n        const length = this.newRecBuffer.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n\n        // Merge all new recorded buffers into a single buffer\n        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)\n\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n\n        let finalBuffer = resampledBuffer // Float32Array\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        // Clear the new recorded buffers after they have been processed\n        this.newRecBuffer.length = 0\n\n        // Post the message to the main thread\n        // The first argument is the message data, containing the encoded WAV buffer\n        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n        // to the main thread, avoiding the need to copy the buffer and improving performance\n        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n        this.port.postMessage(\n            {\n                command: 'newData',\n                recordedData: finalBuffer,\n                sampleRate: this.exportSampleRate,\n                bitDepth: this.exportBitDepth,\n            },\n            []\n        )\n    }\n\n    async getAllRecordedData() {\n        const length = this.recordedBuffers.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n        // Convert to the desired bit depth if necessary\n        let finalBuffer = resampledBuffer\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        this.recordedBuffers.length = 0 // Clear the buffers after extraction\n\n        return finalBuffer\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n";
-//# sourceMappingURL=inlineAudioWebWorker.web.d.ts.map

package/build/workers/inlineAudioWebWorker.web.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inlineAudioWebWorker.web.d.ts","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,urSAyPhC,CAAA"}

package/build/workers/inlineAudioWebWorker.web.js

@@ -1,251 +0,0 @@
-export const InlineAudioWebWorker = `
-const DEFAULT_BIT_DEPTH = 32
-const DEFAULT_SAMPLE_RATE = 44100
-
-class RecorderProcessor extends AudioWorkletProcessor {
-    constructor() {
-        super()
-        this.recordedBuffers = [] // Float32Array
-        this.newRecBuffer = [] // Float32Array
-        this.resampledBuffer = [] // Float32Array
-        this.exportIntervalSamples = 0
-        this.samplesSinceLastExport = 0
-        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten
-        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten
-        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth
-        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten
-        this.numberOfChannels = 1 // Default to 1 channel (mono)
-        this.isRecording = true
-        this.port.onmessage = this.handleMessage.bind(this)
-    }
-
-    handleMessage(event) {
-        switch (event.data.command) {
-            case 'init':
-                this.recordSampleRate = event.data.recordSampleRate
-                this.exportSampleRate =
-                    event.data.exportSampleRate || event.data.recordSampleRate
-                this.exportIntervalSamples =
-                    this.recordSampleRate * (event.data.interval / 1000)
-                if (event.data.numberOfChannels) {
-                    this.numberOfChannels = event.data.numberOfChannels
-                }
-                if (event.data.recordBitDepth) {
-                    this.recordBitDepth = event.data.recordBitDepth
-                }
-                this.exportBitDepth =
-                    event.data.exportBitDepth ||
-                    this.recordBitDepth ||
-                    DEFAULT_BIT_DEPTH
-                break
-            case 'stop':
-                this.isRecording = false
-                this.getAllRecordedData()
-                    .then((fullRecordedData) => {
-                        this.port.postMessage({
-                            command: 'recordedData',
-                            recordedData: fullRecordedData,
-                            bitDepth: this.exportBitDepth,
-                            sampleRate: this.exportSampleRate,
-                        })
-                        return fullRecordedData
-                    })
-                    .catch((error) => {
-                        console.error(
-                            'RecorderProcessor Error extracting recorded data:',
-                            error
-                        )
-                    })
-                break
-        }
-    }
-
-    process(inputs, _outputs, _parameters) {
-        if (!this.isRecording) return true
-        const input = inputs[0]
-        if (input.length > 0) {
-            const newBuffer = new Float32Array(input[0])
-            this.newRecBuffer.push(newBuffer)
-            this.recordedBuffers.push(newBuffer)
-            this.samplesSinceLastExport += newBuffer.length
-
-            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
-                this.exportNewData()
-                this.samplesSinceLastExport = 0
-            }
-        }
-        return true
-    }
-
-    mergeBuffers(bufferArray, recLength) {
-        const result = new Float32Array(recLength)
-        let offset = 0
-        for (let i = 0; i < bufferArray.length; i++) {
-            result.set(bufferArray[i], offset)
-            offset += bufferArray[i].length
-        }
-        return result
-    }
-
-    floatTo16BitPCM(input) {
-        const output = new Int16Array(input.length)
-        for (let i = 0; i < input.length; i++) {
-            const s = Math.max(-1, Math.min(1, input[i]))
-            output[i] = s < 0 ? s * 0x8000 : s * 0x7fff
-        }
-        console.debug(
-            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',
-            output.byteLength
-        )
-        return output
-    }
-
-    floatTo32BitPCM(input) {
-        const output = new Int32Array(input.length)
-        for (let i = 0; i < input.length; i++) {
-            const s = Math.max(-1, Math.min(1, input[i]))
-            output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff
-        }
-        console.debug(
-            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',
-            output.byteLength
-        )
-        return output
-    }
-
-    resample(samples, targetSampleRate) {
-        if (this.recordSampleRate === targetSampleRate) {
-            return samples
-        }
-        const resampledBuffer = new Float32Array(
-            (samples.length * targetSampleRate) / this.recordSampleRate
-        )
-        const ratio = this.recordSampleRate / targetSampleRate
-        let offset = 0
-        for (let i = 0; i < resampledBuffer.length; i++) {
-            const nextOffset = Math.floor((i + 1) * ratio)
-            let accum = 0
-            let count = 0
-            for (let j = offset; j < nextOffset && j < samples.length; j++) {
-                accum += samples[j]
-                count++
-            }
-            resampledBuffer[i] = accum / count
-            offset = nextOffset
-        }
-        return resampledBuffer
-    }
-
-    async resampleBuffer(buffer, targetSampleRate) {
-        if (typeof OfflineAudioContext === 'undefined') {
-            return this.resample(buffer, targetSampleRate)
-        }
-
-        if (this.recordSampleRate === targetSampleRate) {
-            return buffer
-        }
-        const offlineContext = new OfflineAudioContext(
-            this.numberOfChannels,
-            buffer.length,
-            this.recordSampleRate
-        )
-        const sourceBuffer = offlineContext.createBuffer(
-            this.numberOfChannels,
-            buffer.length,
-            this.recordSampleRate
-        )
-        sourceBuffer.copyToChannel(buffer, 0)
-
-        const bufferSource = offlineContext.createBufferSource()
-        bufferSource.buffer = sourceBuffer
-        bufferSource.connect(offlineContext.destination)
-        bufferSource.start()
-
-        const renderedBuffer = await offlineContext.startRendering()
-
-        const resampledBuffer = new Float32Array(renderedBuffer.length)
-        renderedBuffer.copyFromChannel(resampledBuffer, 0)
-
-        return resampledBuffer
-    }
-
-    async exportNewData() {
-        // Calculate the total length of the new recorded buffers
-        const length = this.newRecBuffer.reduce(
-            (acc, buffer) => acc + buffer.length,
-            0
-        )
-
-        // Merge all new recorded buffers into a single buffer
-        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)
-
-        const resampledBuffer = await this.resampleBuffer(
-            mergedBuffer,
-            this.exportSampleRate
-        )
-
-        let finalBuffer = resampledBuffer // Float32Array
-        if (this.recordBitDepth !== this.exportBitDepth) {
-            if (this.exportBitDepth === 16) {
-                finalBuffer = this.floatTo16BitPCM(resampledBuffer)
-            } else if (this.exportBitDepth === 32) {
-                finalBuffer = this.floatTo32BitPCM(resampledBuffer)
-            }
-        }
-
-        const originalSize = mergedBuffer.byteLength
-        const resampledSize = resampledBuffer.byteLength
-        const finalSize = finalBuffer.byteLength
-
-        // Clear the new recorded buffers after they have been processed
-        this.newRecBuffer.length = 0
-
-        // Post the message to the main thread
-        // The first argument is the message data, containing the encoded WAV buffer
-        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer
-        // to the main thread, avoiding the need to copy the buffer and improving performance
-        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);
-        this.port.postMessage(
-            {
-                command: 'newData',
-                recordedData: finalBuffer,
-                sampleRate: this.exportSampleRate,
-                bitDepth: this.exportBitDepth,
-            },
-            []
-        )
-    }
-
-    async getAllRecordedData() {
-        const length = this.recordedBuffers.reduce(
-            (acc, buffer) => acc + buffer.length,
-            0
-        )
-        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)
-        const resampledBuffer = await this.resampleBuffer(
-            mergedBuffer,
-            this.exportSampleRate
-        )
-        // Convert to the desired bit depth if necessary
-        let finalBuffer = resampledBuffer
-        if (this.recordBitDepth !== this.exportBitDepth) {
-            if (this.exportBitDepth === 16) {
-                finalBuffer = this.floatTo16BitPCM(resampledBuffer)
-            } else if (this.exportBitDepth === 32) {
-                finalBuffer = this.floatTo32BitPCM(resampledBuffer)
-            }
-        }
-
-        const originalSize = mergedBuffer.byteLength
-        const resampledSize = resampledBuffer.byteLength
-        const finalSize = finalBuffer.byteLength
-
-        this.recordedBuffers.length = 0 // Clear the buffers after extraction
-
-        return finalBuffer
-    }
-}
-
-registerProcessor('recorder-processor', RecorderProcessor)
-`;
-//# sourceMappingURL=inlineAudioWebWorker.web.js.map

package/build/workers/inlineAudioWebWorker.web.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPnC,CAAA","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32\nconst DEFAULT_SAMPLE_RATE = 44100\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n    constructor() {\n        super()\n        this.recordedBuffers = [] // Float32Array\n        this.newRecBuffer = [] // Float32Array\n        this.resampledBuffer = [] // Float32Array\n        this.exportIntervalSamples = 0\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth\n        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten\n        this.numberOfChannels = 1 // Default to 1 channel (mono)\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\n                this.recordSampleRate = event.data.recordSampleRate\n                this.exportSampleRate =\n                    event.data.exportSampleRate || event.data.recordSampleRate\n                this.exportIntervalSamples =\n                    this.recordSampleRate * (event.data.interval / 1000)\n                if (event.data.numberOfChannels) {\n                    this.numberOfChannels = event.data.numberOfChannels\n                }\n                if (event.data.recordBitDepth) {\n                    this.recordBitDepth = event.data.recordBitDepth\n                }\n                this.exportBitDepth =\n                    event.data.exportBitDepth ||\n                    this.recordBitDepth ||\n                    DEFAULT_BIT_DEPTH\n                break\n            case 'stop':\n                this.isRecording = false\n                this.getAllRecordedData()\n                    .then((fullRecordedData) => {\n                        this.port.postMessage({\n                            command: 'recordedData',\n                            recordedData: fullRecordedData,\n                            bitDepth: this.exportBitDepth,\n                            sampleRate: this.exportSampleRate,\n                        })\n                        return fullRecordedData\n                    })\n                    .catch((error) => {\n                        console.error(\n                            'RecorderProcessor Error extracting recorded data:',\n                            error\n                        )\n                    })\n                break\n        }\n    }\n\n    process(inputs, _outputs, _parameters) {\n        if (!this.isRecording) return true\n        const input = inputs[0]\n        if (input.length > 0) {\n            const newBuffer = new Float32Array(input[0])\n            this.newRecBuffer.push(newBuffer)\n            this.recordedBuffers.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.exportNewData()\n                this.samplesSinceLastExport = 0\n            }\n        }\n        return true\n    }\n\n    mergeBuffers(bufferArray, recLength) {\n        const result = new Float32Array(recLength)\n        let offset = 0\n        for (let i = 0; i < bufferArray.length; i++) {\n            result.set(bufferArray[i], offset)\n            offset += bufferArray[i].length\n        }\n        return result\n    }\n\n    floatTo16BitPCM(input) {\n        const output = new Int16Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x8000 : s * 0x7fff\n        }\n        console.debug(\n            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    floatTo32BitPCM(input) {\n        const output = new Int32Array(input.length)\n        for (let i = 0; i < input.length; i++) {\n            const s = Math.max(-1, Math.min(1, input[i]))\n            output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff\n        }\n        console.debug(\n            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            (samples.length * targetSampleRate) / this.recordSampleRate\n        )\n        const ratio = this.recordSampleRate / targetSampleRate\n        let offset = 0\n        for (let i = 0; i < resampledBuffer.length; i++) {\n            const nextOffset = Math.floor((i + 1) * ratio)\n            let accum = 0\n            let count = 0\n            for (let j = offset; j < nextOffset && j < samples.length; j++) {\n                accum += samples[j]\n                count++\n            }\n            resampledBuffer[i] = accum / count\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    async resampleBuffer(buffer, targetSampleRate) {\n        if (typeof OfflineAudioContext === 'undefined') {\n            return this.resample(buffer, targetSampleRate)\n        }\n\n        if (this.recordSampleRate === targetSampleRate) {\n            return buffer\n        }\n        const offlineContext = new OfflineAudioContext(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        const sourceBuffer = offlineContext.createBuffer(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        sourceBuffer.copyToChannel(buffer, 0)\n\n        const bufferSource = offlineContext.createBufferSource()\n        bufferSource.buffer = sourceBuffer\n        bufferSource.connect(offlineContext.destination)\n        bufferSource.start()\n\n        const renderedBuffer = await offlineContext.startRendering()\n\n        const resampledBuffer = new Float32Array(renderedBuffer.length)\n        renderedBuffer.copyFromChannel(resampledBuffer, 0)\n\n        return resampledBuffer\n    }\n\n    async exportNewData() {\n        // Calculate the total length of the new recorded buffers\n        const length = this.newRecBuffer.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n\n        // Merge all new recorded buffers into a single buffer\n        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)\n\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n\n        let finalBuffer = resampledBuffer // Float32Array\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        // Clear the new recorded buffers after they have been processed\n        this.newRecBuffer.length = 0\n\n        // Post the message to the main thread\n        // The first argument is the message data, containing the encoded WAV buffer\n        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n        // to the main thread, avoiding the need to copy the buffer and improving performance\n        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n        this.port.postMessage(\n            {\n                command: 'newData',\n                recordedData: finalBuffer,\n                sampleRate: this.exportSampleRate,\n                bitDepth: this.exportBitDepth,\n            },\n            []\n        )\n    }\n\n    async getAllRecordedData() {\n        const length = this.recordedBuffers.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n        // Convert to the desired bit depth if necessary\n        let finalBuffer = resampledBuffer\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        this.recordedBuffers.length = 0 // Clear the buffers after extraction\n\n        return finalBuffer\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n`\n"]}

package/expo-module.config.json

@@ -1,9 +0,0 @@
-{
-    "platforms": ["ios", "tvos", "android", "web"],
-    "ios": {
-        "modules": ["ExpoAudioStreamModule"]
-    },
-    "android": {
-        "modules": ["net.siteed.audiostream.ExpoAudioStreamModule"]
-    }
-}

package/plugin/build/index.d.ts

@@ -1,3 +0,0 @@
-import { ConfigPlugin } from '@expo/config-plugins';
-declare const withRecordingPermission: ConfigPlugin;
-export default withRecordingPermission;