uneeq-js 2.47.0 → 2.47.2

package/dist/umd/index.js

@@ -3672,14 +3672,14 @@ const online_status_service_1 = __webpack_require__(320);
 const prom_1 = __webpack_require__(290);
 const resume_session_check_1 = __webpack_require__(321);
 const speech_handler_1 = __webpack_require__(323);
-const stream_manager_1 = __webpack_require__(331);
+const stream_manager_1 = __webpack_require__(334);
 const uneeq_local_storage_1 = __webpack_require__(322);
-const voice_input_manager_1 = __webpack_require__(332);
+const voice_input_manager_1 = __webpack_require__(335);
 const MessageTypes_1 = __webpack_require__(287);
-const NewSessionRequest_1 = __webpack_require__(335);
+const NewSessionRequest_1 = __webpack_require__(338);
 const PublishSubscribeState_1 = __webpack_require__(248);
-const SourceApp_1 = __webpack_require__(336);
-const VoiceInputMode_1 = __webpack_require__(334);
+const SourceApp_1 = __webpack_require__(339);
+const VoiceInputMode_1 = __webpack_require__(337);
 class Uneeq {
     /**
      * The active session id as a string. If the session has not started yet value will be null
@@ -4018,8 +4018,8 @@ class Uneeq {
                 sessionId: this.session.id,
                 messages: this.messages,
                 assetBasePath: this.options.assetBasePath,
-                locales: this.options.speechToTextLocales || "",
-                hintPhrases: this.options.speechRecognitionHintPhrases || ""
+                locales: this.options.speechToTextLocales || '',
+                hintPhrases: this.options.speechRecognitionHintPhrases || ''
             });
         }
         else {
@@ -13240,7 +13240,7 @@ exports.race = race;
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"uneeq-js","version":"2.47.0","description":"","main":"dist/index.js","types":"dist/src/index.d.ts","scripts":{"start":"npx webpack -w","test-local":"npx karma start karma.conf.js -logLevel=DEBUG","test":"npx karma start --browsers ChromeHeadless --single-run","test:windows":"karma start karma.conf.js","build":"webpack --config webpack.config.prod.js && webpack --config webpack.config.umd.js","lint":"npx tslint -p tsconfig.json --fix","docs":"npx typedoc --options"},"files":["dist","!dist/test"],"author":"","license":"ISC","dependencies":{"@stomp/stompjs":"^6.0.0","@uehreka/seriously":"^1.0.1","fast-text-encoding":"^1.0.0","intrinsic-scale":"^3.0.4","onnxruntime-web":"^1.15.1","promjs":"^0.4.1","ring-buffer-ts":"^1.2.0","rxjs":"^7.8.1","rxjs-compat":"^6.6.7","simple-peer":"^9.11.1","webrtc-adapter":"^8.2.3"},"devDependencies":{"@types/dom-mediacapture-record":"^1.0.16","@types/jasmine":"^2.8.8","@types/node":"^10.9.4","fetch-mock":"7.7.3","ignore-styles":"^5.0.1","jasmine":"^5.1.0","jasmine-core":"^5.1.0","karma":"^6.4.2","karma-chrome-launcher":"^3.2.0","karma-firefox-launcher":"^2.1.2","karma-jasmine":"^5.1.0","karma-jasmine-html-reporter":"^2.1.0","karma-requirejs":"^1.1.0","karma-typescript":"^5.5.4","karma-typescript-es6-transform":"^5.5.4","nock":"^9.6.1","requirejs":"^2.3.6","ts-loader":"^9.4.4","ts-node":"^7.0.1","tslint":"^5.11.0","tslint-no-focused-test":"^0.5.0","typedoc":"^0.18.0","typescript":"^5.1.6","webpack":"^5.88.2","webpack-cli":"^5.1.4"}}');
+module.exports = JSON.parse('{"name":"uneeq-js","version":"2.47.1","description":"","main":"dist/index.js","types":"dist/src/index.d.ts","scripts":{"start":"npx webpack -w","test-local":"npx karma start karma.conf.js -logLevel=DEBUG","test":"npx karma start --browsers ChromeHeadless --single-run","test:windows":"karma start karma.conf.js","build":"webpack --config webpack.config.prod.js && webpack --config webpack.config.umd.js","lint":"npx tslint -p tsconfig.json --fix","docs":"npx typedoc --options"},"files":["dist","!dist/test"],"author":"","license":"ISC","dependencies":{"@stomp/stompjs":"^6.0.0","@uehreka/seriously":"^1.0.1","crossoriginworker":"^1.1.0","fast-text-encoding":"^1.0.0","intrinsic-scale":"^3.0.4","onnxruntime-web":"^1.15.1","opus-media-recorder":"^0.8.0","promjs":"^0.4.1","ring-buffer-ts":"^1.2.0","rxjs":"^7.8.1","rxjs-compat":"^6.6.7","simple-peer":"^9.11.1","webrtc-adapter":"^8.2.3"},"devDependencies":{"@types/dom-mediacapture-record":"^1.0.16","@types/jasmine":"^2.8.8","@types/node":"^10.9.4","fetch-mock":"7.7.3","ignore-styles":"^5.0.1","jasmine":"^5.1.0","jasmine-core":"^5.1.0","karma":"^6.4.2","karma-chrome-launcher":"^3.2.0","karma-firefox-launcher":"^2.1.2","karma-jasmine":"^5.1.0","karma-jasmine-html-reporter":"^2.1.0","karma-requirejs":"^1.1.0","karma-typescript":"^5.5.4","karma-typescript-es6-transform":"^5.5.4","nock":"^9.6.1","requirejs":"^2.3.6","ts-loader":"^9.4.4","ts-node":"^7.0.1","tslint":"^5.11.0","tslint-no-focused-test":"^0.5.0","typedoc":"^0.18.0","typescript":"^5.1.6","webpack":"^5.88.2","webpack-cli":"^5.1.4"}}');
 
 /***/ }),
 /* 242 */
@@ -51156,25 +51156,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SpeechHandler = void 0;
-const ring_buffer_ts_1 = __webpack_require__(324);
-const real_time_vad_1 = __webpack_require__(325);
+const opus_media_recorder_1 = __importDefault(__webpack_require__(324));
+const ring_buffer_ts_1 = __webpack_require__(327);
+const real_time_vad_1 = __webpack_require__(328);
 const MessageTypes_1 = __webpack_require__(287);
-const SpeechRecognitionMessageAction_1 = __webpack_require__(330);
+const SpeechRecognitionMessageAction_1 = __webpack_require__(333);
 const logger_1 = __webpack_require__(250);
 const speechBufferLength = 5;
 const audioChunkSizeMs = 100;
 const audioSampleRate = 48000;
 const audioChannelCount = 1;
-const defaultAssetPath = 'https://projects.uneeq.io/libs/vad-assets/';
+const defaultAssetPath = 'https://cdn.uneeq.io/assets/platform/speech-recognition/';
 class SpeechHandler {
     constructor(options) {
         this.options = options;
         this.logPrefix = 'UneeQ: Speech Recognition: ';
         this.speechBuffer = new ring_buffer_ts_1.RingBuffer(speechBufferLength);
         this.recordingLive = false;
-        console.warn("UneeQ: SPEECH_RECOGNITION input mode is in development, you may experience issues.");
+        this.OpusMediaRecorder = opus_media_recorder_1.default;
+        console.warn('UneeQ: SPEECH_RECOGNITION input mode is in development, you may experience issues.');
         this.options.assetBasePath = this.options.assetBasePath || defaultAssetPath;
         this.loadSavedAudioHeaders();
         this.initWebsocket(options);
@@ -51197,7 +51202,7 @@ class SpeechHandler {
     loadSavedAudioHeaders() {
         return __awaiter(this, void 0, void 0, function* () {
             // this will be replaced with opus media recorder lib that will give us the first packets with header
-            const fileName = this.options.assetBasePath + 'chromium-webm-header.webm';
+            const fileName = this.options.assetBasePath + 'opus-media-recorder-header.webm';
             // load the saved header and send that:
             const response = yield fetch(fileName);
             const arrayBuffer = yield response.arrayBuffer();
@@ -51288,14 +51293,37 @@ class SpeechHandler {
             .catch((error) => console.error('Error starting recording', error));
     }
     initMediaRecorder(stream) {
-        const mediaOptions = {
-            mimeType: 'audio/webm;codecs="opus"',
-            audioBitsPerSecond: audioSampleRate
-        };
-        this.mediaRecorder = new MediaRecorder(stream, mediaOptions);
-        this.mediaRecorder.ondataavailable = (e) => this.mediaRecorderOnData(e);
-        this.mediaRecorder.onstop = () => this.sendStopMessage();
-        this.mediaRecorder.start(audioChunkSizeMs);
+        return __awaiter(this, void 0, void 0, function* () {
+            // The script there simply posts back an "Hello" message
+            // Obviously cross-origin here
+            const cross_origin_script_url = this.options.assetBasePath + 'encoderWorker.umd.js';
+            const worker_url = getWorkerURL(cross_origin_script_url);
+            const worker = new Worker(worker_url);
+            // worker.onmessage = (evt) => console.log( evt.data );
+            // URL.revokeObjectURL( worker_url );
+            // Returns a blob:// URL which points
+            // to a javascript file which will call
+            // importScripts with the given URL
+            function getWorkerURL(url) {
+                const content = `importScripts( "${url}" );`;
+                return URL.createObjectURL(new Blob([content], { type: "text/javascript" }));
+            }
+            const workerOptions = {
+                encoderWorkerFactory: () => {
+                    return worker;
+                },
+                OggOpusEncoderWasmPath: this.options.assetBasePath + 'OggOpusEncoder.wasm',
+                WebMOpusEncoderWasmPath: this.options.assetBasePath + 'WebMOpusEncoder.wasm'
+            };
+            const mediaOptions = {
+                mimeType: 'audio/webm',
+                audioBitsPerSecond: audioSampleRate
+            };
+            this.mediaRecorder = new this.OpusMediaRecorder(stream, mediaOptions, workerOptions);
+            this.mediaRecorder.ondataavailable = (e) => this.mediaRecorderOnData(e);
+            this.mediaRecorder.onstop = () => this.sendStopMessage();
+            this.mediaRecorder.start(audioChunkSizeMs);
+        });
     }
     mediaRecorderOnData(event) {
         if (event.data && event.data.size > 0) {
@@ -51320,12 +51348,1537 @@ exports.SpeechHandler = SpeechHandler;
 
 /***/ }),
 /* 324 */
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { EventTarget, defineEventAttribute } = __webpack_require__(325);
+const { detect } = __webpack_require__(326);
+const browser = detect();
+
+const AudioContext = __webpack_require__.g.AudioContext || __webpack_require__.g.webkitAudioContext;
+const BUFFER_SIZE = 4096;
+
+/**
+ * Reference: https://w3c.github.io/mediacapture-record/#mediarecorder-api
+ * @extends EventTarget
+ */
+class OpusMediaRecorder extends EventTarget {
+  /**
+   * A function that returns the encoder web worker
+   * @name workerFactory
+   * @function
+   * @returns {worker} An instance of ./encoderWorker.js web worker.
+   */
+
+  /**
+   *
+   * @param {MediaStream} stream - The MediaStream to be recorded. This will
+   *          be the value of the stream attribute.
+   * @param {MediaRecorderOptions} [options] - A dictionary of options to for
+   *          the UA instructing how the recording will take part.
+   *          options.mimeType, if present, will become the value of mimeType
+   *          attribute.
+   * @param {Object} [workerOptions] This is a NON-STANDARD options to
+   *          configure how to import the web worker .wasm compiled binaries
+   *          used for encoding.
+   * @param {workerFactory} [workerOptions.encoderWorkerFactory] A factory
+   *          function that create a web worker instance of ./encoderWorker.js
+   *          and returns it. function(){return new Worker('./encoderWorker.umd.js')}
+   *          is used by default. This is NON-STANDARD.
+   * @param {string} [workerOptions.OggOpusEncoderWasmPath]
+   *          Path of ./OggOpusEncoder.wasm which is used for OGG Opus encoding
+   *          by the encoder worker. This is NON-STANDARD.
+   * @param {string} [workerOptions.WebMOpusEncoderWasmPath]
+   *          Path of ./WebMOpusEncoder.wasm which is used for WebM Opus encoding
+   *          by the encoder worker. This is NON-STANDARD.
+   */
+  constructor (stream, options = {}, workerOptions = {}) {
+    const { mimeType, audioBitsPerSecond, videoBitsPerSecond, bitsPerSecond } = options; // eslint-disable-line
+    // NON-STANDARD options
+    const { encoderWorkerFactory, OggOpusEncoderWasmPath, WebMOpusEncoderWasmPath } = workerOptions;
+
+    super();
+    // Attributes for the specification conformance. These have their own getters.
+    this._stream = stream;
+    this._state = 'inactive';
+    this._mimeType = mimeType || '';
+    this._audioBitsPerSecond = audioBitsPerSecond || bitsPerSecond;
+    /** @type {'inactive'|'readyToInit'|'encoding'|'closed'} */
+    this.workerState = 'inactive';
+
+    // Parse MIME Type
+    if (!OpusMediaRecorder.isTypeSupported(this._mimeType)) {
+      throw new TypeError('invalid arguments, a MIME Type is not supported');
+    }
+    switch (OpusMediaRecorder._parseType(this._mimeType).subtype) {
+      case 'wave':
+      case 'wav':
+        this._mimeType = 'audio/wave';
+        break;
+
+      case 'webm':
+        this._mimeType = 'audio/webm';
+        break;
+
+      case 'ogg':
+        this._mimeType = 'audio/ogg';
+        break;
+
+      default:
+        // Select a type depending on OS.
+        switch (browser && browser.name) {
+          case 'chrome':
+            this._mimeType = 'audio/webm';
+            break;
+
+          case 'firefox':
+            this._mimeType = 'audio/ogg';
+            break;
+
+          case 'edge':
+            this._mimeType = 'audio/webm';
+            break;
+
+          case 'ios':
+          case 'safari':
+            this._mimeType = 'audio/wave';
+            break;
+
+          default:
+            this._mimeType = 'audio/webm';
+        }
+    }
+    switch (this._mimeType) {
+      case 'audio/wave':
+        this._wasmPath = ''; // wasm is not used
+        break;
+
+      case 'audio/webm':
+        this._wasmPath = WebMOpusEncoderWasmPath || '';
+        break;
+
+      case 'audio/ogg':
+        this._wasmPath = OggOpusEncoderWasmPath || '';
+        break;
+
+      default:
+        throw new Error(`Internal Error: Unexpected MIME Type: ${this._mimeType}`);
+    }
+
+    // Get current directory for worker
+    let workerDir = '';
+    if (document.currentScript) {
+      workerDir = document.currentScript.src;
+    } else if (self.location) {
+      workerDir = self.location.href;
+    }
+    workerDir = workerDir.substr(0, workerDir.lastIndexOf('/')) +
+                '/encoderWorker.umd.js';
+    // If worker function is imported via <script> tag, make it blob to get URL.
+    if (typeof OpusMediaRecorder.encoderWorker === 'function') {
+      workerDir = URL.createObjectURL(new Blob([`(${OpusMediaRecorder.encoderWorker})()`]));
+    }
+
+    // Spawn a encoder worker
+    this._workerFactory = typeof encoderWorkerFactory === 'function'
+                            ? encoderWorkerFactory
+                            : _ => new Worker(workerDir);
+    this._spawnWorker();
+  }
+
+  /**
+   * The MediaStream [GETUSERMEDIA] to be recorded.
+   * @return {MediaStream}
+   */
+  get stream () {
+    return this._stream;
+  }
+
+  /**
+   * The MIME type [RFC2046] that has been selected as the container for
+   * recording. This entry includes all the parameters to the base
+   * mimeType. The UA should be able to play back any of the MIME types
+   * it supports for recording. For example, it should be able to display
+   * a video recording in the HTML <video> tag. The default value for
+   * this property is platform-specific.
+   * @return {string}
+   */
+  get mimeType () {
+    return this._mimeType;
+  }
+
+  /**
+   * The current state of the OpusMediaRecorder object. When the OpusMediaRecorder
+   * is created, the UA MUST set this attribute to inactive.
+   * @return {"inactive"|"recording"|"paused"}
+   */
+  get state () {
+    return this._state;
+  }
+
+  /**
+   * The value of the Video encoding. Unsupported.
+   * @return {undefined}
+   */
+  get videoBitsPerSecond () {
+    // Video encoding is not supported
+    return undefined;
+  }
+
+  /**
+   * The value of the Audio encoding target bit rate that was passed to
+   * the Platform (potentially truncated, rounded, etc), or the calculated one
+   * if the user has specified bitsPerSecond.
+   * @return {number|undefined}
+   */
+  get audioBitsPerSecond () {
+    return this._audioBitsPerSecond;
+  }
+
+  /**
+   * Initialize worker
+   */
+  _spawnWorker () {
+    this.worker = this._workerFactory();
+    this.worker.onmessage = (e) => this._onmessageFromWorker(e);
+    this.worker.onerror = (e) => this._onerrorFromWorker(e);
+
+    this._postMessageToWorker('loadEncoder',
+                              { mimeType: this._mimeType,
+                                wasmPath: this._wasmPath });
+  }
+
+  /**
+   * Post message to the encoder web worker.
+   * @param {"init"|"pushInputData"|"getEncodedData"|"done"} command - Type of message to send to the worker
+   * @param {object} message - Payload to the worker
+   */
+  _postMessageToWorker (command, message = {}) {
+    switch (command) {
+      case 'loadEncoder':
+        let { mimeType, wasmPath } = message;
+        this.worker.postMessage({ command, mimeType, wasmPath });
+        break;
+
+      case 'init':
+        // Initialize the worker
+        let { sampleRate, channelCount, bitsPerSecond } = message;
+        this.worker.postMessage({ command, sampleRate, channelCount, bitsPerSecond });
+        this.workerState = 'encoding';
+
+        // Start streaming
+        this.source.connect(this.processor);
+        this.processor.connect(this.context.destination);
+        let eventToPush = new __webpack_require__.g.Event('start');
+        this.dispatchEvent(eventToPush);
+        break;
+
+      case 'pushInputData':
+        // Pass input audio buffer to the encoder to encode.
+        // The worker MAY trigger 'encodedData'.
+        let { channelBuffers, length, duration } = message;
+        this.worker.postMessage({
+          command, channelBuffers, length, duration
+        });
+        break;
+
+      case 'getEncodedData':
+        // Request encoded result.
+        // Expected 'encodedData' event from the worker
+        this.worker.postMessage({ command });
+        break;
+
+      case 'done':
+        // Tell encoder finallize the job and destory itself.
+        // Expected 'lastEncodedData' event from the worker.
+        this.worker.postMessage({ command });
+        break;
+
+      default:
+        // This is an error case
+        throw new Error('Internal Error: Incorrect postMessage requested.');
+    }
+  }
+
+  /**
+   * onmessage() callback from the worker.
+   * @param {message} event - message from the worker
+   */
+  _onmessageFromWorker (event) {
+    const { command, buffers } = event.data;
+    let eventToPush;
+    switch (command) {
+      case 'readyToInit':
+        const { sampleRate, channelCount } = this;
+        this.workerState = 'readyToInit';
+
+        // If start() is already called initialize worker
+        if (this.state === 'recording') {
+          this._postMessageToWorker('init',
+                                    { sampleRate,
+                                      channelCount,
+                                      bitsPerSecond: this.audioBitsPerSecond});
+        }
+        break;
+
+      case 'encodedData':
+      case 'lastEncodedData':
+        let data = new Blob(buffers, {'type': this._mimeType});
+        eventToPush = new __webpack_require__.g.Event('dataavailable');
+        eventToPush.data = data;
+        this.dispatchEvent(eventToPush);
+
+        // Detect of stop() called before
+        if (command === 'lastEncodedData') {
+          eventToPush = new __webpack_require__.g.Event('stop');
+          this.dispatchEvent(eventToPush);
+
+          this.workerState = 'closed';
+        }
+        break;
+
+      default:
+        break; // Ignore
+    }
+  }
+
+  /**
+   * onerror() callback from the worker.
+   * @param {ErrorEvent} error - error object from the worker
+   */
+  _onerrorFromWorker (error) {
+    // Stop stream first
+    this.source.disconnect();
+    this.processor.disconnect();
+
+    this.worker.terminate();
+    this.workerState = 'closed';
+
+    // Send message to host
+    let message = [
+      'FileName: ' + error.filename,
+      'LineNumber: ' + error.lineno,
+      'Message: ' + error.message
+    ].join(' - ');
+    let errorToPush = new __webpack_require__.g.Event('error');
+    errorToPush.name = 'UnknownError';
+    errorToPush.message = message;
+    this.dispatchEvent(errorToPush);
+  }
+
+  /**
+   * Enable onaudioprocess() callback.
+   * @param {number} timeslice - In seconds. OpusMediaRecorder should request data
+   *                              from the worker every timeslice seconds.
+   */
+  _enableAudioProcessCallback (timeslice) {
+    // pass frame buffers to the worker
+    let elapsedTime = 0;
+    this.processor.onaudioprocess = (e) => {
+      const { inputBuffer, playbackTime } = e; // eslint-disable-line
+      const { sampleRate, length, duration, numberOfChannels } = inputBuffer; // eslint-disable-line
+
+      // Create channel buffers to pass to the worker
+      const channelBuffers = new Array(numberOfChannels);
+      for (let i = 0; i < numberOfChannels; i++) {
+        channelBuffers[i] = inputBuffer.getChannelData(i);
+      }
+
+      // Pass data to the worker
+      const message = { channelBuffers, length, duration };
+      this._postMessageToWorker('pushInputData', message);
+
+      // Calculate time
+      elapsedTime += duration;
+      if (elapsedTime >= timeslice) {
+        this._postMessageToWorker('getEncodedData');
+        elapsedTime = 0;
+      }
+    };
+  }
+
+  /**
+   * Begins recording media; this method can optionally be passed a timeslice
+   * argument with a value in milliseconds.
+   * @param {number} timeslice - If this is specified, the media will be captured
+   *        in separate chunks of that duration, rather than the default behavior
+   *        of recording the media in a single large chunk. In other words, an
+   *        undefined value of timeslice will be understood as the largest long value.
+   */
+  start (timeslice = Number.MAX_SAFE_INTEGER) {
+    if (this.state !== 'inactive') {
+      throw new Error('DOMException: INVALID_STATE_ERR, state must be inactive.');
+    }
+    if (timeslice < 0) {
+      throw new TypeError('invalid arguments, timeslice should be 0 or higher.');
+    }
+    timeslice /= 1000; // Convert milliseconds to seconds
+
+    // Check worker is closed (usually by stop()) and init.
+    if (this.workerState === 'closed') {
+      this._spawnWorker();
+    }
+
+    // Get channel count and sampling rate
+    // channelCount: https://www.w3.org/TR/mediacapture-streams/#media-track-settings
+    // sampleRate: https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/sampleRate
+    this.context = new AudioContext();
+    let tracks = this.stream.getAudioTracks();
+    if (!tracks[0]) {
+      throw new Error('DOMException: UnkownError, media track not found.');
+    }
+    this.channelCount = tracks[0].getSettings().channelCount || 1;
+    this.sampleRate = this.context.sampleRate;
+
+    /** @type {MediaStreamAudioSourceNode} */
+    this.source = this.context.createMediaStreamSource(this.stream);
+    /** @type {ScriptProcessorNode} */
+    this.processor = this.context.createScriptProcessor(BUFFER_SIZE, this.channelCount, this.channelCount);
+
+    // Start recording
+    this._state = 'recording';
+    this._enableAudioProcessCallback(timeslice);
+
+    // If the worker is already loaded then start
+    if (this.workerState === 'readyToInit') {
+      const { sampleRate, channelCount } = this;
+      this._postMessageToWorker('init',
+                                { sampleRate,
+                                  channelCount,
+                                  bitsPerSecond: this.audioBitsPerSecond });
+    }
+  }
+
+  /**
+   * Stops recording, at which point a dataavailable event containing
+   * the final Blob of saved data is fired. No more recording occurs.
+   */
+  stop () {
+    if (this.state === 'inactive') {
+      throw new Error('DOMException: INVALID_STATE_ERR, state must NOT be inactive.');
+    }
+
+    // Stop stream first
+    this.source.disconnect();
+    this.processor.disconnect();
+    this.context.close();
+
+    // Stop event will be triggered at _onmessageFromWorker(),
+    this._postMessageToWorker('done');
+
+    this._state = 'inactive';
+  }
+
+  /**
+   * Pauses the recording of media.
+   */
+  pause () {
+    if (this.state === 'inactive') {
+      throw new Error('DOMException: INVALID_STATE_ERR, state must NOT be inactive.');
+    }
+
+    // Stop stream first
+    this.source.disconnect();
+    this.processor.disconnect();
+
+    let event = new __webpack_require__.g.Event('pause');
+    this.dispatchEvent(event);
+    this._state = 'paused';
+  }
+
+  /**
+   * Resumes recording of media after having been paused.
+   */
+  resume () {
+    if (this.state === 'inactive') {
+      throw new Error('DOMException: INVALID_STATE_ERR, state must NOT be inactive.');
+    }
+
+    // Restart streaming data
+    this.source.connect(this.processor);
+    this.processor.connect(this.context.destination);
+
+    let event = new __webpack_require__.g.Event('resume');
+    this.dispatchEvent(event);
+    this._state = 'recording';
+  }
+
+  /**
+   * Requests a Blob containing the saved data received thus far (or since
+   * the last time requestData() was called. After calling this method,
+   * recording continues, but in a new Blob.
+   */
+  requestData () {
+    if (this.state === 'inactive') {
+      throw new Error('DOMException: INVALID_STATE_ERR, state must NOT be inactive.');
+    }
+
+    // dataavailable event will be triggerd at _onmessageFromWorker()
+    this._postMessageToWorker('getEncodedData');
+  }
+
+  /**
+   * Returns a Boolean value indicating if the given MIME type is supported
+   * by the current user agent .
+   * @param {string} typeType - A MIME Type, including parameters when needed,
+   *          specifying a container and/or codec formats for recording.
+   * @return {boolean}
+   */
+  static isTypeSupported (mimeType) {
+    // See: https://w3c.github.io/mediacapture-record/#dom-mediarecorder-istypesupported
+
+    // 1. If empty string, return true.
+    if (typeof mimeType === 'string' && !mimeType) {
+      return true;
+    }
+    try {
+      var {type, subtype, codec} = OpusMediaRecorder._parseType(mimeType);
+    } catch (error) {
+      // 2. If not a valid string, return false.
+      return false;
+    }
+    if (type !== 'audio' ||
+      !(subtype === 'ogg' || subtype === 'webm' ||
+        subtype === 'wave' || subtype === 'wav')) {
+      // 3,4. If type and subtype are unsupported the return false.
+      return false;
+    }
+    // 5. If codec is unsupported then return false.
+    // 6. If the specified combination of all is not supported than return false.
+    switch (subtype) {
+      case 'ogg':
+        if (codec !== 'opus' && codec) {
+          return false;
+        }
+        break;
+      case 'webm':
+        if (codec !== 'opus' && codec) {
+          return false;
+        }
+        break;
+      case 'wave':
+      case 'wav':
+        if (codec) {
+          return false; // Currently only supports signed 16 bits
+        }
+        break;
+    }
+    // 7. return true.
+    return true;
+  }
+
+  /**
+   * Parse MIME. A helper function for isTypeSupported() and etc.
+   * @param {string} mimeType - typeType - A MIME Type, including parameters when needed,
+   *          specifying a container and/or codec formats for recording.
+   * @return {?object} - An object with type, subtype, codec attributes
+   *          if parsed correctly. null is returned if parsing failed.
+   *          If mimeType is an empty string then return an object with attributes
+   *          are empty strings
+   */
+  static _parseType (mimeType) {
+    try {
+      const regex = /^(\w+)\/(\w+)(;\s*codecs=(\w+))?$/;
+      var [, type, subtype, , codec] = mimeType.match(regex);
+    } catch (error) {
+      if (typeof mimeType === 'string' && !mimeType) {
+        return {type: '', subtype: '', codec: ''};
+      }
+      return null;
+    }
+    return {type, subtype, codec};
+  }
+}
+
+// EventHandler attributes.
+// This code is a non-standard EventTarget but required by event-target-shim.
+[
+  'start', // Called to handle the {@link MediaRecorder#start} event.
+  'stop', // Called to handle the stop event.
+  'dataavailable', /* Called to handle the dataavailable event. The Blob of
+                        recorded data is contained in this event and can be
+                        accessed via its data attribute. */
+  'pause', // Called to handle the pause event.
+  'resume', // Called to handle the resume event.
+  'error' // Called to handle a MediaRecorderErrorEvent.
+].forEach(name => defineEventAttribute(OpusMediaRecorder.prototype, name));
+
+// MS Edge specific monkey patching:
+// onaudioprocess callback cannot be triggered more than twice when postMessage
+// uses the seconde transfer argument. So disable the transfer argument only in Edge.
+if (browser && browser.name === 'edge') {
+  (function () {
+    var original = Worker.prototype.postMessage;
+    Worker.prototype.postMessage = function (message, transfer = null) {
+      original.apply(this, [message]);
+    };
+  })();
+}
+
+module.exports = OpusMediaRecorder;
+
+
+/***/ }),
+/* 325 */
+/***/ ((module, exports) => {
+
+"use strict";
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+/**
+ * @typedef {object} PrivateData
+ * @property {EventTarget} eventTarget The event target.
+ * @property {{type:string}} event The original event object.
+ * @property {number} eventPhase The current event phase.
+ * @property {EventTarget|null} currentTarget The current event target.
+ * @property {boolean} canceled The flag to prevent default.
+ * @property {boolean} stopped The flag to stop propagation immediately.
+ * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
+ * @property {number} timeStamp The unix time.
+ * @private
+ */
+
+/**
+ * Private data for event wrappers.
+ * @type {WeakMap<Event, PrivateData>}
+ * @private
+ */
+const privateData = new WeakMap();
+
+/**
+ * Cache for wrapper classes.
+ * @type {WeakMap<Object, Function>}
+ * @private
+ */
+const wrappers = new WeakMap();
+
+/**
+ * Get private data.
+ * @param {Event} event The event object to get private data.
+ * @returns {PrivateData} The private data of the event.
+ * @private
+ */
+function pd(event) {
+    const retv = privateData.get(event);
+    console.assert(retv != null, "'this' is expected an Event object, but got", event);
+    return retv
+}
+
+/**
+ * @see https://dom.spec.whatwg.org/#interface-event
+ * @private
+ */
+/**
+ * The event wrapper.
+ * @constructor
+ * @param {EventTarget} eventTarget The event target of this dispatching.
+ * @param {Event|{type:string}} event The original event to wrap.
+ */
+function Event(eventTarget, event) {
+    privateData.set(this, {
+        eventTarget,
+        event,
+        eventPhase: 2,
+        currentTarget: eventTarget,
+        canceled: false,
+        stopped: false,
+        passiveListener: null,
+        timeStamp: event.timeStamp || Date.now(),
+    });
+
+    // https://heycam.github.io/webidl/#Unforgeable
+    Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+
+    // Define accessors
+    const keys = Object.keys(event);
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (!(key in this)) {
+            Object.defineProperty(this, key, defineRedirectDescriptor(key));
+        }
+    }
+}
+
+// Should be enumerable, but class methods are not enumerable.
+Event.prototype = {
+    /**
+     * The type of this event.
+     * @type {string}
+     */
+    get type() {
+        return pd(this).event.type
+    },
+
+    /**
+     * The target of this event.
+     * @type {EventTarget}
+     */
+    get target() {
+        return pd(this).eventTarget
+    },
+
+    /**
+     * The target of this event.
+     * @type {EventTarget}
+     */
+    get currentTarget() {
+        return pd(this).currentTarget
+    },
+
+    /**
+     * @returns {EventTarget[]} The composed path of this event.
+     */
+    composedPath() {
+        const currentTarget = pd(this).currentTarget;
+        if (currentTarget == null) {
+            return []
+        }
+        return [currentTarget]
+    },
+
+    /**
+     * Constant of NONE.
+     * @type {number}
+     */
+    get NONE() {
+        return 0
+    },
+
+    /**
+     * Constant of CAPTURING_PHASE.
+     * @type {number}
+     */
+    get CAPTURING_PHASE() {
+        return 1
+    },
+
+    /**
+     * Constant of AT_TARGET.
+     * @type {number}
+     */
+    get AT_TARGET() {
+        return 2
+    },
+
+    /**
+     * Constant of BUBBLING_PHASE.
+     * @type {number}
+     */
+    get BUBBLING_PHASE() {
+        return 3
+    },
+
+    /**
+     * The target of this event.
+     * @type {number}
+     */
+    get eventPhase() {
+        return pd(this).eventPhase
+    },
+
+    /**
+     * Stop event bubbling.
+     * @returns {void}
+     */
+    stopPropagation() {
+        const data = pd(this);
+        if (typeof data.event.stopPropagation === "function") {
+            data.event.stopPropagation();
+        }
+    },
+
+    /**
+     * Stop event bubbling.
+     * @returns {void}
+     */
+    stopImmediatePropagation() {
+        const data = pd(this);
+
+        data.stopped = true;
+        if (typeof data.event.stopImmediatePropagation === "function") {
+            data.event.stopImmediatePropagation();
+        }
+    },
+
+    /**
+     * The flag to be bubbling.
+     * @type {boolean}
+     */
+    get bubbles() {
+        return Boolean(pd(this).event.bubbles)
+    },
+
+    /**
+     * The flag to be cancelable.
+     * @type {boolean}
+     */
+    get cancelable() {
+        return Boolean(pd(this).event.cancelable)
+    },
+
+    /**
+     * Cancel this event.
+     * @returns {void}
+     */
+    preventDefault() {
+        const data = pd(this);
+        if (data.passiveListener != null) {
+            console.warn("Event#preventDefault() was called from a passive listener:", data.passiveListener);
+            return
+        }
+        if (!data.event.cancelable) {
+            return
+        }
+
+        data.canceled = true;
+        if (typeof data.event.preventDefault === "function") {
+            data.event.preventDefault();
+        }
+    },
+
+    /**
+     * The flag to indicate cancellation state.
+     * @type {boolean}
+     */
+    get defaultPrevented() {
+        return pd(this).canceled
+    },
+
+    /**
+     * The flag to be composed.
+     * @type {boolean}
+     */
+    get composed() {
+        return Boolean(pd(this).event.composed)
+    },
+
+    /**
+     * The unix time of this event.
+     * @type {number}
+     */
+    get timeStamp() {
+        return pd(this).timeStamp
+    },
+};
+
+// `constructor` is not enumerable.
+Object.defineProperty(Event.prototype, "constructor", { value: Event, configurable: true, writable: true });
+
+// Ensure `event instanceof window.Event` is `true`.
+if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
+    Object.setPrototypeOf(Event.prototype, window.Event.prototype);
+
+    // Make association for wrappers.
+    wrappers.set(window.Event.prototype, Event);
+}
+
+/**
+ * Get the property descriptor to redirect a given property.
+ * @param {string} key Property name to define property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor to redirect the property.
+ * @private
+ */
+function defineRedirectDescriptor(key) {
+    return {
+        get() {
+            return pd(this).event[key]
+        },
+        set(value) {
+            pd(this).event[key] = value;
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Get the property descriptor to call a given method property.
+ * @param {string} key Property name to define property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor to call the method property.
+ * @private
+ */
+function defineCallDescriptor(key) {
+    return {
+        value() {
+            const event = pd(this).event;
+            return event[key].apply(event, arguments)
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Define new wrapper class.
+ * @param {Function} BaseEvent The base wrapper class.
+ * @param {Object} proto The prototype of the original event.
+ * @returns {Function} The defined wrapper class.
+ * @private
+ */
+function defineWrapper(BaseEvent, proto) {
+    const keys = Object.keys(proto);
+    if (keys.length === 0) {
+        return BaseEvent
+    }
+
+    /** CustomEvent */
+    function CustomEvent(eventTarget, event) {
+        BaseEvent.call(this, eventTarget, event);
+    }
+
+    CustomEvent.prototype = Object.create(BaseEvent.prototype, {
+        constructor: { value: CustomEvent, configurable: true, writable: true },
+    });
+
+    // Define accessors.
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (!(key in BaseEvent.prototype)) {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+            const isFunc = (typeof descriptor.value === "function");
+            Object.defineProperty(
+                CustomEvent.prototype,
+                key,
+                isFunc ? defineCallDescriptor(key) : defineRedirectDescriptor(key)
+            );
+        }
+    }
+
+    return CustomEvent
+}
+
+/**
+ * Get the wrapper class of a given prototype.
+ * @param {Object} proto The prototype of the original event to get its wrapper.
+ * @returns {Function} The wrapper class.
+ * @private
+ */
+function getWrapper(proto) {
+    if (proto == null || proto === Object.prototype) {
+        return Event
+    }
+
+    let wrapper = wrappers.get(proto);
+    if (wrapper == null) {
+        wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
+        wrappers.set(proto, wrapper);
+    }
+    return wrapper
+}
+
+/**
+ * Wrap a given event to management a dispatching.
+ * @param {EventTarget} eventTarget The event target of this dispatching.
+ * @param {Object} event The event to wrap.
+ * @returns {Event} The wrapper instance.
+ * @private
+ */
+function wrapEvent(eventTarget, event) {
+    const Wrapper = getWrapper(Object.getPrototypeOf(event));
+    return new Wrapper(eventTarget, event)
+}
+
+/**
+ * Get the stopped flag of a given event.
+ * @param {Event} event The event to get.
+ * @returns {boolean} The flag to stop propagation immediately.
+ * @private
+ */
+function isStopped(event) {
+    return pd(event).stopped
+}
+
+/**
+ * Set the current event phase of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {number} eventPhase New event phase.
+ * @returns {void}
+ * @private
+ */
+function setEventPhase(event, eventPhase) {
+    pd(event).eventPhase = eventPhase;
+}
+
+/**
+ * Set the current target of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {EventTarget|null} currentTarget New current target.
+ * @returns {void}
+ * @private
+ */
+function setCurrentTarget(event, currentTarget) {
+    pd(event).currentTarget = currentTarget;
+}
+
+/**
+ * Set a passive listener of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {Function|null} passiveListener New passive listener.
+ * @returns {void}
+ * @private
+ */
+function setPassiveListener(event, passiveListener) {
+    pd(event).passiveListener = passiveListener;
+}
+
+/**
+ * @typedef {object} ListenerNode
+ * @property {Function} listener
+ * @property {1|2|3} listenerType
+ * @property {boolean} passive
+ * @property {boolean} once
+ * @property {ListenerNode|null} next
+ * @private
+ */
+
+/**
+ * @type {WeakMap<object, Map<string, ListenerNode>>}
+ * @private
+ */
+const listenersMap = new WeakMap();
+
+// Listener types
+const CAPTURE = 1;
+const BUBBLE = 2;
+const ATTRIBUTE = 3;
+
+/**
+ * Check whether a given value is an object or not.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is an object.
+ */
+function isObject(x) {
+    return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
+}
+
+/**
+ * Get listeners.
+ * @param {EventTarget} eventTarget The event target to get.
+ * @returns {Map<string, ListenerNode>} The listeners.
+ * @private
+ */
+function getListeners(eventTarget) {
+    const listeners = listenersMap.get(eventTarget);
+    if (listeners == null) {
+        throw new TypeError("'this' is expected an EventTarget object, but got another value.")
+    }
+    return listeners
+}
+
+/**
+ * Get the property descriptor for the event attribute of a given event.
+ * @param {string} eventName The event name to get property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor.
+ * @private
+ */
+function defineEventAttributeDescriptor(eventName) {
+    return {
+        get() {
+            const listeners = getListeners(this);
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (node.listenerType === ATTRIBUTE) {
+                    return node.listener
+                }
+                node = node.next;
+            }
+            return null
+        },
+
+        set(listener) {
+            if (typeof listener !== "function" && !isObject(listener)) {
+                listener = null; // eslint-disable-line no-param-reassign
+            }
+            const listeners = getListeners(this);
+
+            // Traverse to the tail while removing old value.
+            let prev = null;
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (node.listenerType === ATTRIBUTE) {
+                    // Remove old value.
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    }
+                    else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    }
+                    else {
+                        listeners.delete(eventName);
+                    }
+                }
+                else {
+                    prev = node;
+                }
+
+                node = node.next;
+            }
+
+            // Add new value.
+            if (listener !== null) {
+                const newNode = {
+                    listener,
+                    listenerType: ATTRIBUTE,
+                    passive: false,
+                    once: false,
+                    next: null,
+                };
+                if (prev === null) {
+                    listeners.set(eventName, newNode);
+                }
+                else {
+                    prev.next = newNode;
+                }
+            }
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Define an event attribute (e.g. `eventTarget.onclick`).
+ * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
+ * @param {string} eventName The event name to define.
+ * @returns {void}
+ */
+function defineEventAttribute(eventTargetPrototype, eventName) {
+    Object.defineProperty(eventTargetPrototype, `on${eventName}`, defineEventAttributeDescriptor(eventName));
+}
+
+/**
+ * Define a custom EventTarget with event attributes.
+ * @param {string[]} eventNames Event names for event attributes.
+ * @returns {EventTarget} The custom EventTarget.
+ * @private
+ */
+function defineCustomEventTarget(eventNames) {
+    /** CustomEventTarget */
+    function CustomEventTarget() {
+        EventTarget.call(this);
+    }
+
+    CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
+        constructor: { value: CustomEventTarget, configurable: true, writable: true },
+    });
+
+    for (let i = 0; i < eventNames.length; ++i) {
+        defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
+    }
+
+    return CustomEventTarget
+}
+
+/**
+ * EventTarget.
+ *
+ * - This is constructor if no arguments.
+ * - This is a function which returns a CustomEventTarget constructor if there are arguments.
+ *
+ * For example:
+ *
+ *     class A extends EventTarget {}
+ *     class B extends EventTarget("message") {}
+ *     class C extends EventTarget("message", "error") {}
+ *     class D extends EventTarget(["message", "error"]) {}
+ */
+function EventTarget() {
+    /*eslint-disable consistent-return */
+    if (this instanceof EventTarget) {
+        listenersMap.set(this, new Map());
+        return
+    }
+    if (arguments.length === 1 && Array.isArray(arguments[0])) {
+        return defineCustomEventTarget(arguments[0])
+    }
+    if (arguments.length > 0) {
+        const types = new Array(arguments.length);
+        for (let i = 0; i < arguments.length; ++i) {
+            types[i] = arguments[i];
+        }
+        return defineCustomEventTarget(types)
+    }
+    throw new TypeError("Cannot call a class as a function")
+    /*eslint-enable consistent-return */
+}
+
+// Should be enumerable, but class methods are not enumerable.
+EventTarget.prototype = {
+    /**
+     * Add a given listener to this event target.
+     * @param {string} eventName The event name to add.
+     * @param {Function} listener The listener to add.
+     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+     * @returns {boolean} `true` if the listener was added actually.
+     */
+    addEventListener(eventName, listener, options) {
+        if (listener == null) {
+            return false
+        }
+        if (typeof listener !== "function" && !isObject(listener)) {
+            throw new TypeError("'listener' should be a function or an object.")
+        }
+
+        const listeners = getListeners(this);
+        const optionsIsObj = isObject(options);
+        const capture = optionsIsObj ? Boolean(options.capture) : Boolean(options);
+        const listenerType = (capture ? CAPTURE : BUBBLE);
+        const newNode = {
+            listener,
+            listenerType,
+            passive: optionsIsObj && Boolean(options.passive),
+            once: optionsIsObj && Boolean(options.once),
+            next: null,
+        };
+
+        // Set it as the first node if the first node is null.
+        let node = listeners.get(eventName);
+        if (node === undefined) {
+            listeners.set(eventName, newNode);
+            return true
+        }
+
+        // Traverse to the tail while checking duplication..
+        let prev = null;
+        while (node != null) {
+            if (node.listener === listener && node.listenerType === listenerType) {
+                // Should ignore duplication.
+                return false
+            }
+            prev = node;
+            node = node.next;
+        }
+
+        // Add it.
+        prev.next = newNode;
+        return true
+    },
+
+    /**
+     * Remove a given listener from this event target.
+     * @param {string} eventName The event name to remove.
+     * @param {Function} listener The listener to remove.
+     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+     * @returns {boolean} `true` if the listener was removed actually.
+     */
+    removeEventListener(eventName, listener, options) {
+        if (listener == null) {
+            return false
+        }
+
+        const listeners = getListeners(this);
+        const capture = isObject(options) ? Boolean(options.capture) : Boolean(options);
+        const listenerType = (capture ? CAPTURE : BUBBLE);
+
+        let prev = null;
+        let node = listeners.get(eventName);
+        while (node != null) {
+            if (node.listener === listener && node.listenerType === listenerType) {
+                if (prev !== null) {
+                    prev.next = node.next;
+                }
+                else if (node.next !== null) {
+                    listeners.set(eventName, node.next);
+                }
+                else {
+                    listeners.delete(eventName);
+                }
+                return true
+            }
+
+            prev = node;
+            node = node.next;
+        }
+
+        return false
+    },
+
+    /**
+     * Dispatch a given event.
+     * @param {Event|{type:string}} event The event to dispatch.
+     * @returns {boolean} `false` if canceled.
+     */
+    dispatchEvent(event) { //eslint-disable-line complexity
+        if (event == null || typeof event.type !== "string") {
+            throw new TypeError("\"event.type\" should be a string.")
+        }
+
+        // If listeners aren't registered, terminate.
+        const listeners = getListeners(this);
+        const eventName = event.type;
+        let node = listeners.get(eventName);
+        if (node == null) {
+            return true
+        }
+
+        // Since we cannot rewrite several properties, so wrap object.
+        const wrappedEvent = wrapEvent(this, event);
+
+        // This doesn't process capturing phase and bubbling phase.
+        // This isn't participating in a tree.
+        let prev = null;
+        while (node != null) {
+            // Remove this listener if it's once
+            if (node.once) {
+                if (prev !== null) {
+                    prev.next = node.next;
+                }
+                else if (node.next !== null) {
+                    listeners.set(eventName, node.next);
+                }
+                else {
+                    listeners.delete(eventName);
+                }
+            }
+            else {
+                prev = node;
+            }
+
+            // Call this listener
+            setPassiveListener(wrappedEvent, (node.passive ? node.listener : null));
+            if (typeof node.listener === "function") {
+                try {
+                    node.listener.call(this, wrappedEvent);
+                }
+                catch (err) {
+                    /*eslint-disable no-console */
+                    if (typeof console !== "undefined" && typeof console.error === "function") {
+                        console.error(err);
+                    }
+                    /*eslint-enable no-console */
+                }
+            }
+            else if (node.listenerType !== ATTRIBUTE && typeof node.listener.handleEvent === "function") {
+                node.listener.handleEvent(wrappedEvent);
+            }
+
+            // Break if `event.stopImmediatePropagation` was called.
+            if (isStopped(wrappedEvent)) {
+                break
+            }
+
+            node = node.next;
+        }
+        setPassiveListener(wrappedEvent, null);
+        setEventPhase(wrappedEvent, 0);
+        setCurrentTarget(wrappedEvent, null);
+
+        return !wrappedEvent.defaultPrevented
+    },
+};
+
+// `constructor` is not enumerable.
+Object.defineProperty(EventTarget.prototype, "constructor", { value: EventTarget, configurable: true, writable: true });
+
+// Ensure `eventTarget instanceof window.EventTarget` is `true`.
+if (typeof window !== "undefined" && typeof window.EventTarget !== "undefined") {
+    Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
+}
+
+exports.defineEventAttribute = defineEventAttribute;
+exports.EventTarget = EventTarget;
+exports["default"] = EventTarget;
+
+module.exports = EventTarget
+module.exports.EventTarget = module.exports["default"] = EventTarget
+module.exports.defineEventAttribute = defineEventAttribute
+//# sourceMappingURL=event-target-shim.js.map
+
+
+/***/ }),
+/* 326 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/* provided dependency */ var process = __webpack_require__(254);
+
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var BrowserInfo = /** @class */ (function () {
+    function BrowserInfo(name, version, os) {
+        this.name = name;
+        this.version = version;
+        this.os = os;
+    }
+    return BrowserInfo;
+}());
+exports.BrowserInfo = BrowserInfo;
+var NodeInfo = /** @class */ (function () {
+    function NodeInfo(version) {
+        this.version = version;
+        this.name = 'node';
+        this.os = process.platform;
+    }
+    return NodeInfo;
+}());
+exports.NodeInfo = NodeInfo;
+var BotInfo = /** @class */ (function () {
+    function BotInfo() {
+        this.bot = true; // NOTE: deprecated test name instead
+        this.name = 'bot';
+        this.version = null;
+        this.os = null;
+    }
+    return BotInfo;
+}());
+exports.BotInfo = BotInfo;
+// tslint:disable-next-line:max-line-length
+var SEARCHBOX_UA_REGEX = /alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/;
+var SEARCHBOT_OS_REGEX = /(nuhk)|(Googlebot)|(Yammybot)|(Openbot)|(Slurp)|(MSNBot)|(Ask Jeeves\/Teoma)|(ia_archiver)/;
+var REQUIRED_VERSION_PARTS = 3;
+var userAgentRules = [
+    ['aol', /AOLShield\/([0-9\._]+)/],
+    ['edge', /Edge\/([0-9\._]+)/],
+    ['edge-ios', /EdgiOS\/([0-9\._]+)/],
+    ['yandexbrowser', /YaBrowser\/([0-9\._]+)/],
+    ['vivaldi', /Vivaldi\/([0-9\.]+)/],
+    ['kakaotalk', /KAKAOTALK\s([0-9\.]+)/],
+    ['samsung', /SamsungBrowser\/([0-9\.]+)/],
+    ['silk', /\bSilk\/([0-9._-]+)\b/],
+    ['miui', /MiuiBrowser\/([0-9\.]+)$/],
+    ['beaker', /BeakerBrowser\/([0-9\.]+)/],
+    ['edge-chromium', /Edg\/([0-9\.]+)/],
+    [
+        'chromium-webview',
+        /(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/,
+    ],
+    ['chrome', /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
+    ['phantomjs', /PhantomJS\/([0-9\.]+)(:?\s|$)/],
+    ['crios', /CriOS\/([0-9\.]+)(:?\s|$)/],
+    ['firefox', /Firefox\/([0-9\.]+)(?:\s|$)/],
+    ['fxios', /FxiOS\/([0-9\.]+)/],
+    ['opera-mini', /Opera Mini.*Version\/([0-9\.]+)/],
+    ['opera', /Opera\/([0-9\.]+)(?:\s|$)/],
+    ['opera', /OPR\/([0-9\.]+)(:?\s|$)/],
+    ['ie', /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
+    ['ie', /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
+    ['ie', /MSIE\s(7\.0)/],
+    ['bb10', /BB10;\sTouch.*Version\/([0-9\.]+)/],
+    ['android', /Android\s([0-9\.]+)/],
+    ['ios', /Version\/([0-9\._]+).*Mobile.*Safari.*/],
+    ['safari', /Version\/([0-9\._]+).*Safari/],
+    ['facebook', /FBAV\/([0-9\.]+)/],
+    ['instagram', /Instagram\s([0-9\.]+)/],
+    ['ios-webview', /AppleWebKit\/([0-9\.]+).*Mobile/],
+    ['ios-webview', /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
+    ['searchbot', SEARCHBOX_UA_REGEX],
+];
+var operatingSystemRules = [
+    ['iOS', /iP(hone|od|ad)/],
+    ['Android OS', /Android/],
+    ['BlackBerry OS', /BlackBerry|BB10/],
+    ['Windows Mobile', /IEMobile/],
+    ['Amazon OS', /Kindle/],
+    ['Windows 3.11', /Win16/],
+    ['Windows 95', /(Windows 95)|(Win95)|(Windows_95)/],
+    ['Windows 98', /(Windows 98)|(Win98)/],
+    ['Windows 2000', /(Windows NT 5.0)|(Windows 2000)/],
+    ['Windows XP', /(Windows NT 5.1)|(Windows XP)/],
+    ['Windows Server 2003', /(Windows NT 5.2)/],
+    ['Windows Vista', /(Windows NT 6.0)/],
+    ['Windows 7', /(Windows NT 6.1)/],
+    ['Windows 8', /(Windows NT 6.2)/],
+    ['Windows 8.1', /(Windows NT 6.3)/],
+    ['Windows 10', /(Windows NT 10.0)/],
+    ['Windows ME', /Windows ME/],
+    ['Open BSD', /OpenBSD/],
+    ['Sun OS', /SunOS/],
+    ['Chrome OS', /CrOS/],
+    ['Linux', /(Linux)|(X11)/],
+    ['Mac OS', /(Mac_PowerPC)|(Macintosh)/],
+    ['QNX', /QNX/],
+    ['BeOS', /BeOS/],
+    ['OS/2', /OS\/2/],
+    ['Search Bot', SEARCHBOT_OS_REGEX],
+];
+function detect(userAgent) {
+    if (!!userAgent) {
+        return parseUserAgent(userAgent);
+    }
+    if (typeof navigator !== 'undefined') {
+        return parseUserAgent(navigator.userAgent);
+    }
+    return getNodeVersion();
+}
+exports.detect = detect;
+function parseUserAgent(ua) {
+    // opted for using reduce here rather than Array#first with a regex.test call
+    // this is primarily because using the reduce we only perform the regex
+    // execution once rather than once for the test and for the exec again below
+    // probably something that needs to be benchmarked though
+    var matchedRule = ua !== '' &&
+        userAgentRules.reduce(function (matched, _a) {
+            var browser = _a[0], regex = _a[1];
+            if (matched) {
+                return matched;
+            }
+            var uaMatch = regex.exec(ua);
+            return !!uaMatch && [browser, uaMatch];
+        }, false);
+    if (!matchedRule) {
+        return null;
+    }
+    var name = matchedRule[0], match = matchedRule[1];
+    if (name === 'searchbot') {
+        return new BotInfo();
+    }
+    var versionParts = match[1] && match[1].split(/[._]/).slice(0, 3);
+    if (versionParts) {
+        if (versionParts.length < REQUIRED_VERSION_PARTS) {
+            versionParts = __spreadArrays(versionParts, createVersionParts(REQUIRED_VERSION_PARTS - versionParts.length));
+        }
+    }
+    else {
+        versionParts = [];
+    }
+    return new BrowserInfo(name, versionParts.join('.'), detectOS(ua));
+}
+exports.parseUserAgent = parseUserAgent;
+function detectOS(ua) {
+    for (var ii = 0, count = operatingSystemRules.length; ii < count; ii++) {
+        var _a = operatingSystemRules[ii], os = _a[0], regex = _a[1];
+        var match = regex.test(ua);
+        if (match) {
+            return os;
+        }
+    }
+    return null;
+}
+exports.detectOS = detectOS;
+function getNodeVersion() {
+    var isNode = typeof process !== 'undefined' && process.version;
+    return isNode ? new NodeInfo(process.version.slice(1)) : null;
+}
+exports.getNodeVersion = getNodeVersion;
+function createVersionParts(count) {
+    var output = [];
+    for (var ii = 0; ii < count; ii++) {
+        output.push('0');
+    }
+    return output;
+}
+
+
+/***/ }),
+/* 327 */
 /***/ (function(module) {
 
 !function(e,t){if(true)module.exports=t();else { var s, r; }}(this,(()=>(()=>{"use strict";var e={d:(t,r)=>{for(var s in r)e.o(r,s)&&!e.o(t,s)&&Object.defineProperty(t,s,{enumerable:!0,get:r[s]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};e.r(t),e.d(t,{RingBuffer:()=>r});class r{static fromArray(e,t=0){const s=new r(t);return s.fromArray(e,0===t),s}constructor(e){if(this.buffer=[],this.pos=0,e<0)throw new RangeError("Invalid size.");this.size=e}getSize(){return this.size}getPos(){return this.pos}getBufferLength(){return this.buffer.length}add(...e){e.forEach((e=>{this.buffer[this.pos]=e,this.pos=(this.pos+1)%this.size}))}get(e){if(e<0&&(e+=this.buffer.length),!(e<0||e>this.buffer.length))return this.buffer.length<this.size?this.buffer[e]:this.buffer[(this.pos+e)%this.size]}getFirst(){return this.get(0)}getLast(){return this.get(-1)}getFirstN(e){return 0===e?[]:e<0?this.getLastN(-e):this.toArray().slice(0,e)}getLastN(e){return 0===e?[]:e<0?this.getFirstN(-e):this.toArray().slice(-e)}remove(e,t=1){if(e<0&&(e+=this.buffer.length),e<0||e>this.buffer.length)return[];const r=this.toArray(),s=r.splice(e,t);return this.fromArray(r),s}removeFirst(){return this.remove(0)[0]}removeLast(){return this.remove(-1)[0]}toArray(){return this.buffer.slice(this.pos).concat(this.buffer.slice(0,this.pos))}fromArray(e,t=!1){if(!Array.isArray(e))throw new TypeError("Input value is not an array.");t&&this.resize(e.length),0!==this.size&&(this.buffer=e.slice(-this.size),this.pos=this.buffer.length%this.size)}clear(){this.buffer=[],this.pos=0}resize(e){if(e<0)throw new RangeError("The size does not allow negative values.");if(0===e)this.clear();else if(e!==this.size){const t=this.toArray();this.fromArray(t.slice(-e)),this.pos=this.buffer.length%e}this.size=e}isFull(){return this.buffer.length===this.size}isEmpty(){return 0===this.buffer.length}}return t})()));
 
 /***/ }),
-/* 325 */
+/* 328 */
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -51374,11 +52927,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AudioNodeVAD = exports.MicVAD = exports.defaultRealTimeVADOptions = void 0;
-const ort = __importStar(__webpack_require__(326));
+const ort = __importStar(__webpack_require__(329));
 const logger_1 = __webpack_require__(250);
-const frame_processor_1 = __webpack_require__(327);
-const messages_1 = __webpack_require__(328);
-const models_1 = __webpack_require__(329);
+const frame_processor_1 = __webpack_require__(330);
+const messages_1 = __webpack_require__(331);
+const models_1 = __webpack_require__(332);
 exports.defaultRealTimeVADOptions = Object.assign(Object.assign({}, frame_processor_1.defaultFrameProcessorOptions), { onFrameProcessed: (probabilities) => { }, onVADMisfire: () => {
         logger_1.logger.debug('VAD misfire');
     }, onSpeechStart: () => {
@@ -51514,7 +53067,7 @@ exports.AudioNodeVAD = AudioNodeVAD;
 
 
 /***/ }),
-/* 326 */
+/* 329 */
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 /* provided dependency */ var process = __webpack_require__(254);
@@ -51527,7 +53080,7 @@ exports.AudioNodeVAD = AudioNodeVAD;
 //# sourceMappingURL=ort.min.js.map
 
 /***/ }),
-/* 327 */
+/* 330 */
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -51548,7 +53101,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.FrameProcessor = exports.validateOptions = exports.defaultFrameProcessorOptions = void 0;
 const logger_1 = __webpack_require__(250);
-const messages_1 = __webpack_require__(328);
+const messages_1 = __webpack_require__(331);
 const RECOMMENDED_FRAME_SAMPLES = [512, 1024, 1536];
 exports.defaultFrameProcessorOptions = {
     positiveSpeechThreshold: 0.5,
@@ -51681,7 +53234,7 @@ exports.FrameProcessor = FrameProcessor;
 
 
 /***/ }),
-/* 328 */
+/* 331 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -51698,7 +53251,7 @@ var Message;
 
 
 /***/ }),
-/* 329 */
+/* 332 */
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -51760,7 +53313,7 @@ Silero.new = (ort, modelFetcher) => __awaiter(void 0, void 0, void 0, function*
 
 
 /***/ }),
-/* 330 */
+/* 333 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -51775,7 +53328,7 @@ var SpeechRecognitionMessageAction;
 
 
 /***/ }),
-/* 331 */
+/* 334 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -51840,7 +53393,7 @@ exports.StreamManager = StreamManager;
 
 
 /***/ }),
-/* 332 */
+/* 335 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -51848,9 +53401,9 @@ exports.StreamManager = StreamManager;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.VoiceInputManager = void 0;
 const operators_1 = __webpack_require__(238);
-const soundmeter_1 = __webpack_require__(333);
+const soundmeter_1 = __webpack_require__(336);
 const MessageTypes_1 = __webpack_require__(287);
-const VoiceInputMode_1 = __webpack_require__(334);
+const VoiceInputMode_1 = __webpack_require__(337);
 const logger_1 = __webpack_require__(250);
 class VoiceInputManager {
     constructor(options, api, messages, enableMicrophone) {
@@ -52018,7 +53571,7 @@ exports.VoiceInputManager = VoiceInputManager;
 
 
 /***/ }),
-/* 333 */
+/* 336 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -52097,7 +53650,7 @@ exports.SoundMeter = SoundMeter;
 
 
 /***/ }),
-/* 334 */
+/* 337 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -52113,7 +53666,7 @@ var VoiceInputMode;
 
 
 /***/ }),
-/* 335 */
+/* 338 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -52127,7 +53680,7 @@ var SessionType;
 
 
 /***/ }),
-/* 336 */
+/* 339 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";