react-native-audio-api/lib/commonjs/mock/index.js

react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AnalyserNode = void 0;
Object.defineProperty(exports, "AnalyserOptions", {
  enumerable: true,
  get: function () {
    return _types.AnalyserOptions;
  }
});
exports.AudioBufferSourceNode = exports.AudioBufferQueueSourceNode = exports.AudioBuffer = exports.AudioApiError = void 0;
Object.defineProperty(exports, "AudioBufferSourceOptions", {
  enumerable: true,
  get: function () {
    return _types.AudioBufferSourceOptions;
  }
});
exports.AudioContext = void 0;
Object.defineProperty(exports, "AudioContextOptions", {
  enumerable: true,
  get: function () {
    return _types.AudioContextOptions;
  }
});
exports.AudioRecorder = exports.AudioParam = exports.AudioNode = exports.AudioManager = exports.AudioDestinationNode = void 0;
Object.defineProperty(exports, "AudioRecorderCallbackOptions", {
  enumerable: true,
  get: function () {
    return _types.AudioRecorderCallbackOptions;
  }
});
Object.defineProperty(exports, "AudioRecorderFileOptions", {
  enumerable: true,
  get: function () {
    return _types.AudioRecorderFileOptions;
  }
});
Object.defineProperty(exports, "AudioRecorderStartOptions", {
  enumerable: true,
  get: function () {
    return _types.AudioRecorderStartOptions;
  }
});
exports.AudioScheduledSourceNode = void 0;
Object.defineProperty(exports, "AudioWorkletRuntime", {
  enumerable: true,
  get: function () {
    return _types.AudioWorkletRuntime;
  }
});
Object.defineProperty(exports, "BaseAudioBufferSourceOptions", {
  enumerable: true,
  get: function () {
    return _types.BaseAudioBufferSourceOptions;
  }
});
exports.BiquadFilterNode = exports.BaseAudioContext = void 0;
Object.defineProperty(exports, "BiquadFilterOptions", {
  enumerable: true,
  get: function () {
    return _types.BiquadFilterOptions;
  }
});
Object.defineProperty(exports, "BiquadFilterType", {
  enumerable: true,
  get: function () {
    return _types.BiquadFilterType;
  }
});
Object.defineProperty(exports, "ChannelCountMode", {
  enumerable: true,
  get: function () {
    return _types.ChannelCountMode;
  }
});
Object.defineProperty(exports, "ChannelInterpretation", {
  enumerable: true,
  get: function () {
    return _types.ChannelInterpretation;
  }
});
exports.ConstantSourceNode = void 0;
Object.defineProperty(exports, "ConstantSourceOptions", {
  enumerable: true,
  get: function () {
    return _types.ConstantSourceOptions;
  }
});
Object.defineProperty(exports, "ContextState", {
  enumerable: true,
  get: function () {
    return _types.ContextState;
  }
});
exports.ConvolverNode = void 0;
Object.defineProperty(exports, "ConvolverOptions", {
  enumerable: true,
  get: function () {
    return _types.ConvolverOptions;
  }
});
exports.DelayNode = void 0;
Object.defineProperty(exports, "DelayOptions", {
  enumerable: true,
  get: function () {
    return _types.DelayOptions;
  }
});
Object.defineProperty(exports, "FileDirectory", {
  enumerable: true,
  get: function () {
    return _types.FileDirectory;
  }
});
Object.defineProperty(exports, "FileFormat", {
  enumerable: true,
  get: function () {
    return _types.FileFormat;
  }
});
Object.defineProperty(exports, "FileInfo", {
  enumerable: true,
  get: function () {
    return _types.FileInfo;
  }
});
exports.FilePreset = void 0;
Object.defineProperty(exports, "FilePresetType", {
  enumerable: true,
  get: function () {
    return _types.FilePresetType;
  }
});
exports.GainNode = void 0;
Object.defineProperty(exports, "GainOptions", {
  enumerable: true,
  get: function () {
    return _types.GainOptions;
  }
});
exports.OfflineAudioContext = exports.NotificationManager = exports.NotSupportedError = exports.MediaElementAudioSourceNode = exports.InvalidStateError = exports.InvalidAccessError = exports.IndexSizeError = void 0;
Object.defineProperty(exports, "OfflineAudioContextOptions", {
  enumerable: true,
  get: function () {
    return _types.OfflineAudioContextOptions;
  }
});
exports.OscillatorNode = void 0;
Object.defineProperty(exports, "OscillatorOptions", {
  enumerable: true,
  get: function () {
    return _types.OscillatorOptions;
  }
});
Object.defineProperty(exports, "OscillatorType", {
  enumerable: true,
  get: function () {
    return _types.OscillatorType;
  }
});
Object.defineProperty(exports, "OverSampleType", {
  enumerable: true,
  get: function () {
    return _types.OverSampleType;
  }
});
exports.PeriodicWave = void 0;
Object.defineProperty(exports, "PeriodicWaveOptions", {
  enumerable: true,
  get: function () {
    return _types.PeriodicWaveOptions;
  }
});
exports.RecordingNotificationManager = exports.RecorderAdapterNode = exports.RangeError = exports.PlaybackNotificationManager = void 0;
Object.defineProperty(exports, "Result", {
  enumerable: true,
  get: function () {
    return _types.Result;
  }
});
exports.StereoPannerNode = void 0;
Object.defineProperty(exports, "StereoPannerOptions", {
  enumerable: true,
  get: function () {
    return _types.StereoPannerOptions;
  }
});
exports.StreamerNode = void 0;
Object.defineProperty(exports, "StreamerOptions", {
  enumerable: true,
  get: function () {
    return _types.StreamerOptions;
  }
});
exports.WaveShaperNode = void 0;
Object.defineProperty(exports, "WaveShaperOptions", {
  enumerable: true,
  get: function () {
    return _types.WaveShaperOptions;
  }
});
exports.useSystemVolume = exports.setMockSystemVolume = exports.isFfmpegEnabled = exports.getAudioDuration = exports.default = exports.decodePCMInBase64 = exports.decodeAudioData = exports.concatAudioFiles = exports.WorkletSourceNode = exports.WorkletProcessingNode = exports.WorkletNode = void 0;
var _types = require("../types");
/* eslint-disable no-useless-constructor */

const noop = () => {};
class MockEventSubscription {
  subscriptionId = Number(1).toString();
  remove = noop;
}
class MockAudioEventEmitter {
  listeners = {};
  addAudioEventListener(event, callback) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
    const subscription = new MockEventSubscription();
    subscription.remove = () => {
      const index = this.listeners[event]?.indexOf(callback);
      if (index && index > -1) {
        this.listeners[event].splice(index, 1);
      }
    };
    return subscription;
  }
  emit(event, data) {
    this.listeners[event]?.forEach(callback => callback(data));
  }
}
class AudioParamMock {
  _value = 0;
  defaultValue = 0;
  minValue = -3.4028235e38;
  maxValue = 3.4028235e38;
  constructor(_audioParam, _context) {}
  get value() {
    return this._value;
  }
  set value(newValue) {
    this._value = newValue;
  }
  setValueAtTime(value, _startTime) {
    this._value = value;
    return this;
  }
  linearRampToValueAtTime(value, _endTime) {
    this._value = value;
    return this;
  }
  exponentialRampToValueAtTime(value, _endTime) {
    this._value = value;
    return this;
  }
  setTargetAtTime(target, _startTime, _timeConstant) {
    this._value = target;
    return this;
  }
  setValueCurveAtTime(_values, _startTime, _duration) {
    return this;
  }
  cancelScheduledValues(_startTime) {
    return this;
  }
  cancelAndHoldAtTime(_startTime) {
    return this;
  }
}
class AudioBufferMock {
  constructor(options) {
    this.numberOfChannels = options.numberOfChannels;
    this.length = options.length;
    this.sampleRate = options.sampleRate;
    this.duration = options.length / options.sampleRate;
  }
  getChannelData(_channel) {
    return new Float32Array(this.length);
  }
  copyFromChannel(_destination, _channelNumber, _startInChannel) {}
  copyToChannel(_source, _channelNumber, _startInChannel) {}
}
class AudioNodeMock {
  numberOfInputs = 1;
  numberOfOutputs = 1;
  channelCount = 2;
  channelCountMode = 'max';
  channelInterpretation = 'speakers';
  constructor(context, _node) {
    this.context = context;
  }
  connect(destination) {
    if (destination instanceof AudioParamMock) {
      return;
    }
    return destination;
  }
  disconnect(_destination) {}
}
class AudioScheduledSourceNodeMock extends AudioNodeMock {
  _onended = null;
  constructor(context, node) {
    super(context, node);
  }
  start(_when = 0) {}
  stop(_when = 0) {}
  get onended() {
    return this._onended;
  }
  set onended(callback) {
    this._onended = callback;
  }
}
class AnalyserNodeMock extends AudioNodeMock {
  fftSize = 2048;
  frequencyBinCount = 1024;
  minDecibels = -100;
  maxDecibels = -30;
  smoothingTimeConstant = 0.8;
  constructor(context, _options) {
    super(context, {});
  }
  getByteFrequencyData(_array) {}
  getByteTimeDomainData(_array) {}
  getFloatFrequencyData(_array) {}
  getFloatTimeDomainData(_array) {}
}
class GainNodeMock extends AudioNodeMock {
  constructor(context, _options) {
    super(context, {});
    this.gain = new AudioParamMock({}, context);
    this.gain.value = 1;
  }
}
class DelayNodeMock extends AudioNodeMock {
  constructor(context, _options) {
    super(context, {});
    this.delayTime = new AudioParamMock({}, context);
    this.delayTime.maxValue = 1;
  }
}
class BiquadFilterNodeMock extends AudioNodeMock {
  _type = 'lowpass';
  constructor(context, _options) {
    super(context, {});
    this.frequency = new AudioParamMock({}, context);
    this.detune = new AudioParamMock({}, context);
    this.Q = new AudioParamMock({}, context);
    this.gain = new AudioParamMock({}, context);
    this.frequency.value = 350;
    this.Q.value = 1;
    this.gain.value = 0;
  }
  get type() {
    return this._type;
  }
  set type(value) {
    this._type = value;
  }
  getFrequencyResponse(_frequencyHz, _magResponse, _phaseResponse) {}
}
class ConvolverNodeMock extends AudioNodeMock {
  _buffer = null;
  normalize = true;
  constructor(context, _options) {
    super(context, {});
  }
  get buffer() {
    return this._buffer;
  }
  set buffer(value) {
    this._buffer = value;
  }
}
class WaveShaperNodeMock extends AudioNodeMock {
  _curve = null;
  _oversample = 'none';
  constructor(context, _options) {
    super(context, {});
  }
  get curve() {
    return this._curve;
  }
  set curve(value) {
    this._curve = value;
  }
  get oversample() {
    return this._oversample;
  }
  set oversample(value) {
    this._oversample = value;
  }
}
class StereoPannerNodeMock extends AudioNodeMock {
  constructor(context, _options) {
    super(context, {});
    this.pan = new AudioParamMock({}, context);
  }
}
class OscillatorNodeMock extends AudioScheduledSourceNodeMock {
  _type = 'sine';
  constructor(context, _options) {
    super(context, {});
    this.frequency = new AudioParamMock({}, context);
    this.detune = new AudioParamMock({}, context);
    this.frequency.value = 440;
  }
  get type() {
    return this._type;
  }
  set type(value) {
    this._type = value;
  }
  setPeriodicWave(_wave) {}
}
class ConstantSourceNodeMock extends AudioScheduledSourceNodeMock {
  constructor(context, _options) {
    super(context, {});
    this.offset = new AudioParamMock({}, context);
    this.offset.value = 1;
  }
}
class AudioBufferSourceNodeMock extends AudioScheduledSourceNodeMock {
  _buffer = null;
  _loop = false;
  _loopStart = 0;
  _loopEnd = 0;
  constructor(context, _options) {
    super(context, {});
    this.playbackRate = new AudioParamMock({}, context);
    this.playbackRate.value = 1;
  }
  get buffer() {
    return this._buffer;
  }
  set buffer(value) {
    this._buffer = value;
  }
  get loop() {
    return this._loop;
  }
  set loop(value) {
    this._loop = value;
  }
  get loopStart() {
    return this._loopStart;
  }
  set loopStart(value) {
    this._loopStart = value;
  }
  get loopEnd() {
    return this._loopEnd;
  }
  set loopEnd(value) {
    this._loopEnd = value;
  }
}
class RecorderAdapterNodeMock extends AudioNodeMock {
  wasConnected = false;
  constructor(context) {
    super(context, {});
  }
  getNode() {
    return {};
  }
}
class AudioBufferQueueSourceNodeMock extends AudioScheduledSourceNodeMock {
  _onBufferEnded = null;
  eventEmitter = new MockAudioEventEmitter();
  constructor(context, _options) {
    super(context, {});
  }
  enqueueBuffer(_buffer) {
    return Math.random().toString(36).substr(2, 9);
  }
  dequeueBuffer(_bufferId) {}
  clearBuffers() {}
  pause() {}
  get onBufferEnded() {
    return this._onBufferEnded;
  }
  set onBufferEnded(callback) {
    this._onBufferEnded = callback;
  }
}
class StreamerNodeMock extends AudioScheduledSourceNodeMock {
  streamPath = '';
  constructor(context, options) {
    super(context, options);
    this.streamPath = options.streamPath;
  }
  pause() {}
  resume() {}
}
class MediaElementAudioSourceNodeMock extends AudioNodeMock {
  constructor(context, mediaElement) {
    super(context, {});
    this.mediaElement = mediaElement;
    this.numberOfInputs = 0;
  }
}
class WorkletNodeMock extends AudioNodeMock {
  constructor(context, _runtime, _callback, _bufferLength, _inputChannelCount) {
    super(context, {});
  }
}
class WorkletProcessingNodeMock extends AudioNodeMock {
  constructor(context, _runtime, _callback) {
    super(context, {});
  }
}
class WorkletSourceNodeMock extends AudioScheduledSourceNodeMock {
  constructor(context, _runtime, _callback) {
    super(context, {});
  }
}
class PeriodicWaveMock {
  constructor(_context, _options) {}
}
class AudioDestinationNodeMock extends AudioNodeMock {
  maxChannelCount = 2;
  constructor(context) {
    super(context, {});
    this.numberOfOutputs = 0;
  }
}
class BaseAudioContextMock {
  _sampleRate = 44100;
  _currentTime = 0;
  _state = 'running';
  constructor(options) {
    this.destination = new AudioDestinationNodeMock(this);
    if (options?.sampleRate) {
      this._sampleRate = options.sampleRate;
    }
  }
  get currentTime() {
    return this._currentTime;
  }
  get sampleRate() {
    return this._sampleRate;
  }
  get state() {
    return this._state;
  }
  createBuffer(numberOfChannels, length, sampleRate) {
    return new AudioBufferMock({
      numberOfChannels,
      length,
      sampleRate
    });
  }
  createPeriodicWave(_real, _imag, _constraints) {
    return new PeriodicWaveMock(this);
  }
  decodeAudioData(_audioData) {
    return Promise.resolve(new AudioBufferMock({
      numberOfChannels: 2,
      length: 44100,
      sampleRate: 44100
    }));
  }
  createAnalyser(options) {
    return new AnalyserNodeMock(this, options);
  }
  createBiquadFilter(options) {
    return new BiquadFilterNodeMock(this, options);
  }
  createBufferSource(options) {
    return new AudioBufferSourceNodeMock(this, options);
  }
  createChannelMerger(_numberOfInputs) {
    return new AudioNodeMock(this, {});
  }
  createChannelSplitter(_numberOfOutputs) {
    return new AudioNodeMock(this, {});
  }
  createConstantSource(options) {
    return new ConstantSourceNodeMock(this, options);
  }
  createConvolver(options) {
    return new ConvolverNodeMock(this, options);
  }
  createDelay(options) {
    return new DelayNodeMock(this, options);
  }
  createGain(options) {
    return new GainNodeMock(this, options);
  }
  createOscillator(options) {
    return new OscillatorNodeMock(this, options);
  }
  createStereoPanner(options) {
    return new StereoPannerNodeMock(this, options);
  }
  createWaveShaper(options) {
    return new WaveShaperNodeMock(this, options);
  }
  createRecorderAdapter() {
    return new RecorderAdapterNodeMock(this);
  }
  createBufferQueueSource(options) {
    return new AudioBufferQueueSourceNodeMock(this, options);
  }
  createStreamer(options) {
    return new StreamerNodeMock(this, options);
  }
  createWorkletNode(_shareableWorklet, _runOnUI, _bufferLength, _inputChannelCount) {
    return new WorkletNodeMock(this, 'AudioRuntime', noop, 0, 0);
  }
  createWorkletProcessingNode(_shareableWorklet, _runOnUI) {
    return new WorkletProcessingNodeMock(this, 'AudioRuntime', noop);
  }
  createWorkletSourceNode(_shareableWorklet, _runOnUI) {
    return new WorkletSourceNodeMock(this, 'AudioRuntime', noop);
  }
}
class AudioContextMock extends BaseAudioContextMock {
  constructor(options) {
    super(options);
  }
  close() {
    this._state = 'closed';
    return Promise.resolve();
  }
  resume() {
    this._state = 'running';
    return Promise.resolve();
  }
  suspend() {
    this._state = 'suspended';
    return Promise.resolve();
  }
  createMediaElementSource(mediaElement) {
    return new MediaElementAudioSourceNodeMock(this, mediaElement);
  }
}
class OfflineAudioContextMock extends BaseAudioContextMock {
  constructor(options) {
    super({
      sampleRate: options.sampleRate
    });
    this.length = options.length;
  }
  startRendering() {
    return Promise.resolve(new AudioBufferMock({
      numberOfChannels: 2,
      length: this.length,
      sampleRate: this.sampleRate
    }));
  }
}
class AudioRecorderMock {
  _isRecording = false;
  _isPaused = false;
  _currentDuration = 0;
  _options = null;
  isFileOutputEnabled = false;
  eventEmitter = new MockAudioEventEmitter();
  onAudioReadySubscription = null;
  onErrorSubscription = null;
  constructor() {}
  enableFileOutput(options) {
    this._options = options || {};
    this.isFileOutputEnabled = true;
    return {
      status: 'success',
      path: '/mock/path/recordings'
    };
  }
  get options() {
    return this._options;
  }
  disableFileOutput() {
    this._options = null;
    this.isFileOutputEnabled = false;
  }
  start(options) {
    this._isRecording = true;
    this._isPaused = false;
    const path = options?.fileNameOverride || 'recording.m4a';
    return Promise.resolve({
      status: 'success',
      path
    });
  }
  stop() {
    this._isRecording = false;
    this._isPaused = false;
    this._currentDuration = 0;
    return Promise.resolve({
      status: 'success',
      paths: ['/mock/path/recording.m4a'],
      size: 12345,
      duration: 5.0
    });
  }
  pause() {
    this._isPaused = true;
  }
  resume() {
    this._isPaused = false;
  }
  connect(_node) {
    if (_node.wasConnected) {
      throw new Error('RecorderAdapterNode cannot be connected more than once');
    }
    _node.wasConnected = true;
  }
  disconnect() {}
  onAudioReady(_options, callback) {
    if (this.onAudioReadySubscription) {
      this.onAudioReadySubscription.remove();
    }
    this.onAudioReadySubscription = this.eventEmitter.addAudioEventListener('audioReady', callback);
    return {
      status: 'success'
    };
  }
  clearOnAudioReady() {
    if (this.onAudioReadySubscription) {
      this.onAudioReadySubscription.remove();
      this.onAudioReadySubscription = null;
    }
  }
  isRecording() {
    return this._isRecording;
  }
  isPaused() {
    return this._isPaused;
  }
  getCurrentDuration() {
    return this._currentDuration;
  }
  onError(callback) {
    if (this.onErrorSubscription) {
      this.onErrorSubscription.remove();
    }
    this.onErrorSubscription = this.eventEmitter.addAudioEventListener('recorderError', callback);
  }
  clearOnError() {
    if (this.onErrorSubscription) {
      this.onErrorSubscription.remove();
      this.onErrorSubscription = null;
    }
  }
}
const decodeAudioData = _audioData => {
  return Promise.resolve(new AudioBufferMock({
    numberOfChannels: 2,
    length: 44100,
    sampleRate: 44100
  }));
};
exports.decodeAudioData = decodeAudioData;
const decodePCMInBase64 = _base64Data => {
  return Promise.resolve(new AudioBufferMock({
    numberOfChannels: 2,
    length: 44100,
    sampleRate: 44100
  }));
};
exports.decodePCMInBase64 = decodePCMInBase64;
const getAudioDuration = _input => {
  if (_input instanceof ArrayBuffer) {
    return Promise.resolve(1);
  }
  if (typeof _input === 'string' && _input.startsWith('data:audio/') && _input.includes(';base64,')) {
    return Promise.reject(new AudioApiErrorMock('Base64 source decoding is not currently supported, to decode raw PCM base64 strings use decodePCMInBase64 method.'));
  }
  if (typeof _input === 'string' && _input.startsWith('blob:')) {
    return Promise.reject(new AudioApiErrorMock('Data Blob string decoding is not currently supported.'));
  }
  return Promise.resolve(1);
};
exports.getAudioDuration = getAudioDuration;
const changePlaybackSpeed = (buffer, _speed) => {
  return Promise.resolve(buffer);
};
const concatAudioFiles = (inputPaths, outputPath) => {
  if (!Array.isArray(inputPaths) || inputPaths.length === 0) {
    return Promise.reject(new AudioApiErrorMock('concatAudioFiles requires at least one input path.'));
  }
  if (inputPaths.some(inputPath => typeof inputPath !== 'string')) {
    return Promise.reject(new TypeError('concatAudioFiles input paths must be strings.'));
  }
  if (typeof outputPath !== 'string' || outputPath.length === 0) {
    return Promise.reject(new AudioApiErrorMock('concatAudioFiles requires an output path.'));
  }
  return Promise.resolve(outputPath);
};
exports.concatAudioFiles = concatAudioFiles;
const isFfmpegEnabled = () => true;
exports.isFfmpegEnabled = isFfmpegEnabled;
class AudioManagerMock {
  static getDevicePreferredSampleRate() {
    return 44100;
  }
  static observeVolumeChanges(_observe) {}
  static addSystemEventListener(_event, _callback) {
    return {
      remove: noop
    };
  }
  static removeSystemEventListener(_listener) {}
}
class NotificationManagerMock {
  static create(_options) {
    return {
      update: noop,
      destroy: noop
    };
  }
}
class PlaybackNotificationManagerMock {
  static create(_options) {
    return {
      update: noop,
      destroy: noop
    };
  }
}
class RecordingNotificationManagerMock {
  static create(_options) {
    return {
      update: noop,
      destroy: noop
    };
  }
}
let mockSystemVolumeValue = 0.5;
const useSystemVolume = () => mockSystemVolumeValue;
exports.useSystemVolume = useSystemVolume;
const setMockSystemVolume = volume => {
  mockSystemVolumeValue = volume;
};
exports.setMockSystemVolume = setMockSystemVolume;
class FilePresetMock {
  static get Low() {
    return {};
  }
  static get Medium() {
    return {};
  }
  static get High() {
    return {};
  }
  static get Lossless() {
    return {};
  }
}
class NotSupportedErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'NotSupportedError';
  }
}
class InvalidAccessErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'InvalidAccessError';
  }
}
class InvalidStateErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'InvalidStateError';
  }
}
class IndexSizeErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'IndexSizeError';
  }
}
class RangeErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'RangeError';
  }
}
class AudioApiErrorMock extends Error {
  constructor(message) {
    super(message);
    this.name = 'AudioApiError';
  }
}

// Export classes with original API names (for compatibility)
const AnalyserNode = exports.AnalyserNode = AnalyserNodeMock;
const AudioBuffer = exports.AudioBuffer = AudioBufferMock;
const AudioBufferQueueSourceNode = exports.AudioBufferQueueSourceNode = AudioBufferQueueSourceNodeMock;
const AudioBufferSourceNode = exports.AudioBufferSourceNode = AudioBufferSourceNodeMock;
const AudioContext = exports.AudioContext = AudioContextMock;
const AudioDestinationNode = exports.AudioDestinationNode = AudioDestinationNodeMock;
const AudioNode = exports.AudioNode = AudioNodeMock;
const AudioParam = exports.AudioParam = AudioParamMock;
const AudioRecorder = exports.AudioRecorder = AudioRecorderMock;
const AudioScheduledSourceNode = exports.AudioScheduledSourceNode = AudioScheduledSourceNodeMock;
const BaseAudioContext = exports.BaseAudioContext = BaseAudioContextMock;
const BiquadFilterNode = exports.BiquadFilterNode = BiquadFilterNodeMock;
const ConstantSourceNode = exports.ConstantSourceNode = ConstantSourceNodeMock;
const ConvolverNode = exports.ConvolverNode = ConvolverNodeMock;
const DelayNode = exports.DelayNode = DelayNodeMock;
const GainNode = exports.GainNode = GainNodeMock;
const MediaElementAudioSourceNode = exports.MediaElementAudioSourceNode = MediaElementAudioSourceNodeMock;
const OfflineAudioContext = exports.OfflineAudioContext = OfflineAudioContextMock;
const OscillatorNode = exports.OscillatorNode = OscillatorNodeMock;
const RecorderAdapterNode = exports.RecorderAdapterNode = RecorderAdapterNodeMock;
const StereoPannerNode = exports.StereoPannerNode = StereoPannerNodeMock;
const StreamerNode = exports.StreamerNode = StreamerNodeMock;
const WaveShaperNode = exports.WaveShaperNode = WaveShaperNodeMock;
const WorkletNode = exports.WorkletNode = WorkletNodeMock;
const WorkletProcessingNode = exports.WorkletProcessingNode = WorkletProcessingNodeMock;
const WorkletSourceNode = exports.WorkletSourceNode = WorkletSourceNodeMock;
const PeriodicWave = exports.PeriodicWave = PeriodicWaveMock;
const AudioManager = exports.AudioManager = AudioManagerMock;
const NotificationManager = exports.NotificationManager = NotificationManagerMock;
const PlaybackNotificationManager = exports.PlaybackNotificationManager = PlaybackNotificationManagerMock;
const RecordingNotificationManager = exports.RecordingNotificationManager = RecordingNotificationManagerMock;
const FilePreset = exports.FilePreset = FilePresetMock;
const NotSupportedError = exports.NotSupportedError = NotSupportedErrorMock;
const InvalidAccessError = exports.InvalidAccessError = InvalidAccessErrorMock;
const InvalidStateError = exports.InvalidStateError = InvalidStateErrorMock;
const IndexSizeError = exports.IndexSizeError = IndexSizeErrorMock;
const RangeError = exports.RangeError = RangeErrorMock;
const AudioApiError = exports.AudioApiError = AudioApiErrorMock;

// Export functions

// Type exports to allow using classes as types

// Export types and enums
var _default = exports.default = {
  AnalyserNode: AnalyserNodeMock,
  AudioBuffer: AudioBufferMock,
  AudioBufferQueueSourceNode: AudioBufferQueueSourceNodeMock,
  AudioBufferSourceNode: AudioBufferSourceNodeMock,
  AudioContext: AudioContextMock,
  AudioDestinationNode: AudioDestinationNodeMock,
  AudioNode: AudioNodeMock,
  AudioParam: AudioParamMock,
  AudioRecorder: AudioRecorderMock,
  AudioScheduledSourceNode: AudioScheduledSourceNodeMock,
  BaseAudioContext: BaseAudioContextMock,
  BiquadFilterNode: BiquadFilterNodeMock,
  ConstantSourceNode: ConstantSourceNodeMock,
  ConvolverNode: ConvolverNodeMock,
  DelayNode: DelayNodeMock,
  GainNode: GainNodeMock,
  MediaElementAudioSourceNode: MediaElementAudioSourceNodeMock,
  OfflineAudioContext: OfflineAudioContextMock,
  OscillatorNode: OscillatorNodeMock,
  RecorderAdapterNode: RecorderAdapterNodeMock,
  StereoPannerNode: StereoPannerNodeMock,
  StreamerNode: StreamerNodeMock,
  WaveShaperNode: WaveShaperNodeMock,
  WorkletNode: WorkletNodeMock,
  WorkletProcessingNode: WorkletProcessingNodeMock,
  WorkletSourceNode: WorkletSourceNodeMock,
  PeriodicWave: PeriodicWaveMock,
  // Functions
  decodeAudioData,
  decodePCMInBase64,
  getAudioDuration,
  changePlaybackSpeed,
  concatAudioFiles,
  isFfmpegEnabled,
  useSystemVolume,
  setMockSystemVolume,
  // System classes
  AudioManager: AudioManagerMock,
  NotificationManager: NotificationManagerMock,
  PlaybackNotificationManager: PlaybackNotificationManagerMock,
  RecordingNotificationManager: RecordingNotificationManagerMock,
  // Utils
  FilePreset: FilePresetMock,
  // Errors
  NotSupportedError: NotSupportedErrorMock,
  InvalidAccessError: InvalidAccessErrorMock,
  InvalidStateError: InvalidStateErrorMock,
  IndexSizeError: IndexSizeErrorMock,
  RangeError: RangeErrorMock,
  AudioApiError: AudioApiErrorMock,
  // Enums
  FileDirectory: _types.FileDirectory,
  FileFormat: _types.FileFormat
};
//# sourceMappingURL=index.js.map