twilio-video 2.22.2 → 2.24.1

package/lib/media/track/localaudiotrack.js

@@ -15,6 +15,9 @@ const LocalMediaAudioTrack = mixinLocalMediaTrack(AudioTrack);
  * @property {Track.ID} id - The {@link LocalAudioTrack}'s ID
  * @property {boolean} isStopped - Whether or not the {@link LocalAudioTrack} is
  *   stopped
+ * @property {NoiseCancellation?} noiseCancellation - When a LocalAudioTrack is created
+ *   with {@link NoiseCancellationOptions}, this property provides interface
+ *   to enable or disable the noise cancellation at runtime.
  * @emits LocalAudioTrack#disabled
  * @emits LocalAudioTrack#enabled
  * @emits LocalAudioTrack#started
@@ -27,7 +30,16 @@ class LocalAudioTrack extends LocalMediaAudioTrack {
    * @param {LocalTrackOptions} [options] - {@link LocalTrack} options
    */
   constructor(mediaStreamTrack, options) {
+    const noiseCancellation = options?.noiseCancellation || null;
     super(mediaStreamTrack, options);
+
+    Object.defineProperties(this, {
+      noiseCancellation: {
+        enumerable: true,
+        value: noiseCancellation,
+        writable: false
+      },
+    });
   }
 
   toString() {
@@ -47,6 +59,20 @@ class LocalAudioTrack extends LocalMediaAudioTrack {
     return super._end.apply(this, arguments);
   }
 
+  /**
+   * @private
+   */
+  _reacquireTrack(constraints)  {
+    this._log.debug('_reacquireTrack: ', constraints);
+    if (this.noiseCancellation) {
+      return this.noiseCancellation.reacquireTrack(() => {
+        return super._reacquireTrack.call(this, constraints);
+      });
+    }
+
+    return super._reacquireTrack.call(this, constraints);
+  }
+
   /**
    * Disable the {@link LocalAudioTrack}. This is effectively "mute".
    * @returns {this}
@@ -118,6 +144,9 @@ class LocalAudioTrack extends LocalMediaAudioTrack {
    * @fires LocalAudioTrack#stopped
    */
   stop() {
+    if (this.noiseCancellation) {
+      this.noiseCancellation.stop();
+    }
     return super.stop.apply(this, arguments);
   }
 }
@@ -151,3 +180,4 @@ class LocalAudioTrack extends LocalMediaAudioTrack {
  */
 
 module.exports = LocalAudioTrack;
+

package/lib/media/track/localvideotrack.js

@@ -312,7 +312,7 @@ function workaroundSilentLocalVideo(localVideoTrack, doc) {
     }).finally(() => {
       // If silent frames were not detected, then pause the dummy element again.
       el = localVideoTrack._dummyEl;
-      if (!el.paused) {
+      if (el && !el.paused) {
         el.pause();
       }
 

package/lib/media/track/noisecancellationimpl.ts

@@ -0,0 +1,176 @@
+'use strict';
+
+import { NoiseCancellation, NoiseCancellationOptions, NoiseCancellationVendor } from '../../../tsdef/types';
+import { AudioProcessor } from '../../../tsdef/AudioProcessor';
+import { createNoiseCancellationAudioProcessor } from '../../noisecancellationadapter';
+const Log = require('../../util/log');
+
+/**
+ * {@link NoiseCancellation} interface provides methods to control noise cancellation at runtime. This interface is exposed
+ * on {@link LocalAudioTrack} property `noiseCancellation`. It is available only when {@link NoiseCancellationOptions} are
+ * specified when creating a {@link LocalAudioTrack}, and the plugin is successfully loaded.
+ * @alias NoiseCancellation
+ * @interface
+ *
+ * @example
+ * const { connect, createLocalAudioTrack } = require('twilio-video');
+ *
+ * // Create a LocalAudioTrack with Krisp noise cancellation enabled.
+ * const localAudioTrack = await createLocalAudioTrack({
+ *   noiseCancellationOptions: {
+ *     sdkAssetsPath: 'path/to/hosted/twilio/krisp/audio/plugin/1.0.0/dist',
+ *     vendor: 'krisp'
+ *   }
+ * });
+ *
+ * if (!localAudioTrack.noiseCancellation) {
+ *   // If the Krisp audio plugin fails to load, then a warning message will be logged
+ *   // in the browser console, and the "noiseCancellation" property will be set to null.
+ *   // You can still use the LocalAudioTrack to join a Room. However, it will use the
+ *   // browser's noise suppression instead of the Krisp noise cancellation. Make sure
+ *   // the "sdkAssetsPath" provided in "noiseCancellationOptions" points to the correct
+ *   // hosted path of the plugin assets.
+ * } else {
+ *   // Join a Room with the LocalAudioTrack.
+ *   const room = await connect('token', {
+ *     name: 'my-cool-room',
+ *     tracks: [localAudioTrack]
+ *   });
+ *
+ *   if (!localAudioTrack.noiseCancellation.isEnabled) {
+ *     // Krisp noise cancellation is permanently disabled in Peer-to-Peer and Go Rooms.
+ *   }
+ * }
+ *
+ * //
+ * // Enable/disable noise cancellation.
+ * // @param {boolean} enable - whether noise cancellation should be enabled
+ * //
+ * function setNoiseCancellation(enable) {
+ *   const { noiseCancellation } = localAudioTrack;
+ *   if (noiseCancellation) {
+ *     if (enable) {
+ *       // If enabled, then the LocalAudioTrack will use the Krisp noise
+ *       // cancellation instead of the browser's noise suppression.
+ *       noiseCancellation.enable();
+ *     } else {
+ *       // If disabled, then the LocalAudioTrack will use the browser's
+ *       // noise suppression instead of the Krisp noise cancellation.
+ *       noiseCancellation.disable();
+ *     }
+ *   }
+ * }
+ */
+export class NoiseCancellationImpl implements NoiseCancellation {
+  private _processor: AudioProcessor;
+  private _sourceTrack: MediaStreamTrack;
+  private _disabledPermanent: boolean;
+
+  constructor(processor: AudioProcessor, originalTrack: MediaStreamTrack) {
+    this._processor = processor;
+    this._sourceTrack = originalTrack;
+    this._disabledPermanent = false;
+  }
+
+  /**
+   * Name of the noise cancellation vendor.
+   * @type {NoiseCancellationVendor}
+   */
+  get vendor(): NoiseCancellationVendor {
+    return this._processor.vendor;
+  }
+
+  /**
+   * The underlying MediaStreamTrack of the {@link LocalAudioTrack}.
+   * @type {MediaStreamTrack}
+   */
+  get sourceTrack(): MediaStreamTrack {
+    return this._sourceTrack;
+  }
+
+  /**
+   * Whether noise cancellation is enabled.
+   * @type {boolean}
+   */
+  get isEnabled(): boolean {
+    return this._processor.isEnabled();
+  }
+
+  /**
+   * Enable noise cancellation.
+   * @returns {Promise<void>} Promise that resolves when the operation is complete
+   * @throws {Error} Throws an error if noise cancellation is disabled permanently
+   *   for the {@link LocalAudioTrack}
+   */
+  enable() : Promise<void> {
+    if (this._disabledPermanent) {
+      throw new Error(`${this.vendor} noise cancellation is disabled permanently for this track`);
+    }
+
+    this._processor.enable();
+    return Promise.resolve();
+  }
+
+  /**
+   * Disable noise cancellation.
+   * @returns {Promise<void>} Promise that resolves when the operation is complete
+   */
+  disable() : Promise<void> {
+    this._processor.disable();
+    return Promise.resolve();
+  }
+
+  /**
+   * @private
+   */
+  async reacquireTrack(reacquire: () => Promise<MediaStreamTrack>) : Promise<MediaStreamTrack>  {
+    const processorWasEnabled = this._processor.isEnabled();
+    this._processor.disconnect();
+
+    const track = await reacquire();
+    this._sourceTrack = track;
+
+    const processedTrack = await this._processor.connect(track);
+    if (processorWasEnabled) {
+      this._processor.enable();
+    } else {
+      this._processor.disable();
+    }
+    return processedTrack;
+  }
+
+  /**
+   * @private
+   */
+  disablePermanently(): Promise<void> {
+    this._disabledPermanent = true;
+    return this.disable();
+  }
+
+
+  /**
+   * @private
+   */
+  stop(): void {
+    this._processor.disconnect();
+    this._sourceTrack.stop();
+  }
+}
+
+
+export async function applyNoiseCancellation(
+  mediaStreamTrack: MediaStreamTrack,
+  noiseCancellationOptions: NoiseCancellationOptions,
+  log: typeof Log
+) : Promise<{ cleanTrack: MediaStreamTrack, noiseCancellation?: NoiseCancellation }> {
+  try {
+    const processor = await createNoiseCancellationAudioProcessor(noiseCancellationOptions, log);
+    const cleanTrack = processor.connect(mediaStreamTrack);
+    const noiseCancellation = new NoiseCancellationImpl(processor, mediaStreamTrack);
+    return { cleanTrack, noiseCancellation };
+  } catch (ex) {
+    // in case of failures to load noise cancellation library just return original media stream.
+    log.warn(`Failed to create noise cancellation. Returning normal audio track: ${ex}`);
+    return { cleanTrack: mediaStreamTrack };
+  }
+}

package/lib/noisecancellationadapter.ts

@@ -0,0 +1,134 @@
+/* eslint-disable no-console */
+'use strict';
+import { AudioProcessor } from '../tsdef/AudioProcessor';
+import { NoiseCancellationOptions } from '../tsdef/types';
+const Log = require('./util/log');
+
+const dynamicImport = require('./vendor/dynamicimport');
+
+const PLUGIN_CONFIG = {
+  krisp: {
+    supportedVersion: '1.0.0',
+    pluginFile: 'krispsdk.mjs'
+  },
+  rnnoise: {
+    supportedVersion: '0.6.0',
+    pluginFile: 'rnnoise_sdk.mjs'
+  }
+};
+// AudioProcessor assumes following interface from the Plugin
+interface NoiseCancellationPlugin {
+  init(options: { rootDir: string }): Promise<void>;
+  isInitialized(): boolean;
+  isConnected(): boolean;
+  isEnabled(): boolean
+  connect(input: MediaStream): MediaStream;
+  disconnect(): void;
+  enable(): void;
+  disable(): void;
+  destroy(): void;
+  setLogging(enable: boolean):void;
+  isSupported(audioContext: AudioContext):boolean;
+  getVersion(): string;
+}
+
+const ensureVersionSupported = ({ supportedVersion, plugin, log }: {supportedVersion: string, plugin: NoiseCancellationPlugin, log: typeof Log}) : void => {
+  if (!plugin.getVersion || !plugin.isSupported) {
+    throw new Error('Plugin does not export getVersion/isSupported api. Are you using old version of the plugin ?');
+  }
+
+  const pluginVersion = plugin.getVersion();
+  log.debug(`Plugin Version = ${pluginVersion}`);
+  const supportedVersions = supportedVersion.split('.').map(version => Number(version));
+  const pluginVersions = pluginVersion.split('.').map(version => Number(version));
+  if (supportedVersions.length !== 3 || pluginVersions.length !== 3) {
+    throw new Error(`Unsupported Plugin version format: ${supportedVersion}, ${pluginVersion}`);
+  }
+
+  if (supportedVersions[0] !== pluginVersions[0]) {
+    throw new Error(`Major version mismatch: [Plugin version ${pluginVersion}],  [Supported Version ${supportedVersion}]`);
+  }
+
+  if (pluginVersions[1] < supportedVersions[1]) {
+    throw new Error(`Minor version mismatch: [Plugin version ${pluginVersion}] < [Supported Version ${supportedVersion}]`);
+  }
+
+  const tempContext = new AudioContext();
+  const isSupported = plugin.isSupported(tempContext);
+  tempContext.close();
+  if (!isSupported) {
+    throw new Error('Noise Cancellation plugin is not supported on your browser');
+  }
+};
+
+let audioProcessors = new Map<string, AudioProcessor>();
+export async function createNoiseCancellationAudioProcessor(
+  noiseCancellationOptions: NoiseCancellationOptions,
+  log: typeof Log
+) : Promise<AudioProcessor> {
+  let audioProcessor = audioProcessors.get(noiseCancellationOptions.vendor);
+  if (!audioProcessor) {
+    let pluginConfig = PLUGIN_CONFIG[noiseCancellationOptions.vendor];
+    if (!pluginConfig) {
+      throw new Error(`Unsupported NoiseCancellationOptions.vendor: ${noiseCancellationOptions.vendor}`);
+    }
+
+    const { supportedVersion, pluginFile } =  pluginConfig;
+    const  rootDir = noiseCancellationOptions.sdkAssetsPath;
+    const  sdkFilePath = `${rootDir}/${pluginFile}`;
+
+    try {
+      log.debug('loading noise cancellation sdk: ', sdkFilePath);
+      const dynamicModule = await dynamicImport(sdkFilePath);
+      log.debug('Loaded noise cancellation sdk:', dynamicModule);
+
+      const plugin = dynamicModule.default as NoiseCancellationPlugin;
+      ensureVersionSupported({
+        supportedVersion,
+        plugin,
+        log
+      });
+
+      if (!plugin.isInitialized()) {
+        log.debug('initializing noise cancellation sdk: ', rootDir);
+        await plugin.init({ rootDir });
+        log.debug('noise cancellation sdk initialized!');
+      }
+
+      audioProcessor = {
+        vendor: noiseCancellationOptions.vendor,
+        isInitialized: () => plugin.isInitialized(),
+        isConnected: () => plugin.isConnected(),
+        isEnabled: () => plugin.isEnabled(),
+        disconnect: () => plugin.disconnect(),
+        enable: () => plugin.enable(),
+        disable: () => plugin.disable(),
+        destroy: () => plugin.destroy(),
+        setLogging: (enable: boolean) => plugin.setLogging(enable),
+        connect: (sourceTrack: MediaStreamTrack) => {
+          log.debug('connect: ', sourceTrack.id);
+          if (plugin.isConnected()) {
+            plugin.disconnect();
+          }
+
+          const mediaStream = plugin.connect(new MediaStream([sourceTrack]));
+          if (!mediaStream) {
+            throw new Error('Error connecting with noise cancellation sdk');
+          }
+          const cleanTrack = mediaStream.getAudioTracks()[0];
+          if (!cleanTrack) {
+            throw new Error('Error getting clean track from noise cancellation sdk');
+          }
+          plugin.enable();
+          return cleanTrack;
+        },
+      };
+      audioProcessors.set(noiseCancellationOptions.vendor, audioProcessor);
+
+    } catch (er) {
+      log.error(`Error loading noise cancellation sdk:${sdkFilePath}`, er);
+      throw er;
+    }
+  }
+  return audioProcessor;
+}

package/lib/preflight/preflighttest.ts

@@ -9,7 +9,7 @@ import { getTurnCredentials } from './getturncredentials';
 import { makeStat } from './makestat';
 import { syntheticAudio } from './syntheticaudio';
 import { syntheticVideo } from './syntheticvideo';
-import { waitForSometime } from '../util';
+import { waitForSometime } from '../util/index';
 
 const { WS_SERVER } = require('../util/constants');
 const Log = require('../util/log');

package/lib/room.js

@@ -130,6 +130,7 @@ class Room extends EventEmitter {
     handleLocalParticipantEvents(this, localParticipant);
     handleRecordingEvents(this, signaling.recording);
     handleSignalingEvents(this, signaling);
+    verifyNoiseCancellation(this);
 
     log.info('Created a new Room:', this.name);
     log.debug('Initial RemoteParticipants:', Array.from(this._participants.values()));
@@ -139,6 +140,7 @@ class Room extends EventEmitter {
     return `[Room #${this._instanceId}: ${this.sid}]`;
   }
 
+
   /**
    * Disconnect from the {@link Room}.
    * @returns {this}
@@ -171,6 +173,17 @@ class Room extends EventEmitter {
   }
 }
 
+function verifyNoiseCancellation(room) {
+  const allowedAudioProcessors = room.localParticipant._signaling.audioProcessors;
+  room.localParticipant.audioTracks.forEach(({ track }) => {
+    const noiseCancellation = track.noiseCancellation;
+    if (noiseCancellation && !allowedAudioProcessors.includes(noiseCancellation.vendor)) {
+      room._log.warn(`${noiseCancellation.vendor} is not supported in this room. disabling it permanently`);
+      noiseCancellation.disablePermanently();
+    }
+  });
+}
+
 function rewriteLocalTrackIds(room, trackStats) {
   const localParticipantSignaling = room.localParticipant._signaling;
   return trackStats.reduce((trackStats, trackStat) => {

package/lib/signaling/localparticipant.js

@@ -19,10 +19,11 @@ class LocalParticipantSignaling extends ParticipantSignaling {
    * @param {DataTrackSender|MediaTrackSender} trackSender
    * @param {string} name
    * @param {Track.Priority} priority
+   * @param {?NoiseCancellationVendor} noiseCancellationVendor
    * @returns {LocalTrackPublicationSignaling} publication
    */
-  addTrack(trackSender, name, priority) {
-    const publication = this._createLocalTrackPublicationSignaling(trackSender, name, priority);
+  addTrack(trackSender, name, priority, noiseCancellationVendor = null) {
+    const publication = this._createLocalTrackPublicationSignaling(trackSender, name, priority, noiseCancellationVendor);
     this._trackSendersToPublications.set(trackSender, publication);
     this._publicationsToTrackSenders.set(publication, trackSender);
     super.addTrack(publication);

package/lib/signaling/v2/cancelableroomsignalingpromise.js

@@ -124,9 +124,6 @@ function createCancelableRoomSignalingPromise(token, wsServer, localParticipant,
         reject(new SignalingIncomingMessageInvalidError());
         return;
       }
-
-      const { options: { signaling_region: signalingRegion } } = initialState;
-      localParticipant.setSignalingRegion(signalingRegion);
       resolve(new RoomV2(localParticipant, initialState, transport, peerConnectionManager, options));
     });
 

package/lib/signaling/v2/localparticipant.js

@@ -65,6 +65,10 @@ class LocalParticipantV2 extends LocalParticipantSignaling {
         value: null,
         writable: true
       },
+      audioProcessors: {
+        value: [],
+        writable: true
+      },
       bandwidthProfile: {
         enumerable: true,
         get() {
@@ -125,6 +129,14 @@ class LocalParticipantV2 extends LocalParticipantSignaling {
     }
   }
 
+  /**
+   * Sets the AudioProcessors enabled for this room.
+   * @param {string[]} audioProcessors
+   */
+  setAudioProcessors(audioProcessors) {
+    this.audioProcessors = audioProcessors;
+  }
+
   /**
    * returns current {@link EncodingParametersImpl}.
    * @returns {EncodingParametersImpl}
@@ -184,10 +196,11 @@ class LocalParticipantV2 extends LocalParticipantSignaling {
    * @param {DataTrackSender|MediaTrackSender} trackSender
    * @param {string} name
    * @param {Track.Priority} priority
+   * @param {?NoiseCancellationVendor} noiseCancellationVendor
    * @returns {LocalTrackPublicationV2}
    */
-  _createLocalTrackPublicationSignaling(trackSender, name, priority) {
-    return new this._LocalTrackPublicationV2(trackSender, name, priority, { log: this._log });
+  _createLocalTrackPublicationSignaling(trackSender, name, priority, noiseCancellationVendor) {
+    return new this._LocalTrackPublicationV2(trackSender, name, priority, noiseCancellationVendor, { log: this._log });
   }
 
   /**
@@ -198,8 +211,8 @@ class LocalParticipantV2 extends LocalParticipantSignaling {
    * @param {Track.Priority} priority
    * @returns {this}
    */
-  addTrack(trackSender, name, priority) {
-    super.addTrack(trackSender, name, priority);
+  addTrack(trackSender, name, priority, noiseCancellationVendor) {
+    super.addTrack(trackSender, name, priority, noiseCancellationVendor);
     const publication = this.getPublication(trackSender);
 
     let {

package/lib/signaling/v2/localtrackpublication.js

@@ -13,10 +13,12 @@ class LocalTrackPublicationV2 extends LocalTrackPublicationSignaling {
    * @param {DataTrackSender|MediaTrackSender} trackSender
    * @param {string} name
    * @param {Track.Priority} priority
+   * @param {?NoiseCancellationVendor} noiseCancellationVendor
    * @param {object} [options]
    */
-  constructor(trackSender, name, priority, options) {
+  constructor(trackSender, name, priority, noiseCancellationVendor, options) {
     super(trackSender, name, priority);
+
     Object.defineProperties(this, {
       _log: {
         value: options.log.createLog('default', this)
@@ -24,6 +26,9 @@ class LocalTrackPublicationV2 extends LocalTrackPublicationSignaling {
       _mediaStates: {
         value: { recordings: null },
         writable: true
+      },
+      _noiseCancellationVendor: {
+        value: noiseCancellationVendor,
       }
     });
   }
@@ -33,13 +38,19 @@ class LocalTrackPublicationV2 extends LocalTrackPublicationSignaling {
    * @returns {LocalTrackPublicationV2#Representation} - without the SID
    */
   getState() {
-    return {
+    const state = {
       enabled: this.isEnabled,
       id: this.id,
       kind: this.kind,
       name: this.name,
-      priority: this.updatedPriority
+      priority: this.updatedPriority,
     };
+
+    if (this._noiseCancellationVendor) {
+      // eslint-disable-next-line camelcase
+      state.audio_processor = this._noiseCancellationVendor;
+    }
+    return state;
   }
 
   toString() {

package/lib/signaling/v2/room.js

@@ -52,6 +52,18 @@ class RoomV2 extends RoomSignaling {
     }, options);
 
     localParticipant.setBandwidthProfile(options.bandwidthProfile);
+
+    const { options: { signaling_region: signalingRegion, audio_processors: audioProcessors = [] } } = initialState;
+    localParticipant.setSignalingRegion(signalingRegion);
+
+
+    if (audioProcessors.includes('krisp')) {
+      // Note(mpatwardhan): we add rnnoise as allowed_processor to enable testing our pipeline e2e.
+      audioProcessors.push('rnnoise');
+    }
+
+    localParticipant.setAudioProcessors(audioProcessors);
+
     peerConnectionManager.setIceReconnectTimeout(options.sessionTimeout);
 
     super(localParticipant, initialState.sid, initialState.name, options);
@@ -154,7 +166,7 @@ class RoomV2 extends RoomSignaling {
     this._update(initialState);
 
     // NOTE(mpatwardhan) after initial state we know if publisher_hints are enabled or not
-    // if they are not enabled. we need to undo simulcast that if it was enabled with initial offer.
+    // if they are not enabled. we need to undo simulcast that was enabled with initial offer.
     this._peerConnectionManager.setEffectiveAdaptiveSimulcast(this._publisherHintsSignaling.isSetup);
   }
 

package/lib/vendor/dynamicimport.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2018 uupaa and 2019 Google LLC
+ * Licensed under the MIT license.
+ *
+ * Copied from https://github.com/GoogleChromeLabs/dynamic-import-polyfill
+ */
+
+module.exports = (function(scope) {
+  const { document, location, Blob, URL } = scope;
+  if ([document, location, Blob, URL].some(api => !api)) {
+    return function dynamicImportNotSupported(module) {
+      return Promise.reject(new Error(`Failed to import: ${module}: dynamicImport is not supported`));
+    };
+  }
+  const cleanupScript = script =>  {
+    URL.revokeObjectURL(script.src);
+    script.remove();
+  };
+  scope.__twilioImportedModules = {
+    // Imported module map.
+  };
+  return function dynamicImport(module) {
+    return new Promise((resolve, reject) => {
+      const absURL = new URL(module, location);
+      const moduleBlob = new Blob([
+        `import * as m from '${absURL}';`,
+        `window.__twilioImportedModules['${absURL}']=m;`
+      ], { type: 'text/javascript' });
+      const script = Object.assign(document.createElement('script'), {
+        type: 'module',
+        src: URL.createObjectURL(moduleBlob),
+        onerror() {
+          cleanupScript(script);
+          reject(new Error(`Failed to import: ${absURL}`));
+        },
+        onload() {
+          cleanupScript(script);
+          resolve(scope.__twilioImportedModules[absURL]);
+        },
+      });
+      document.head.appendChild(script);
+    });
+  };
+}(globalThis));

package/package.json

@@ -2,7 +2,7 @@
   "name": "twilio-video",
   "title": "Twilio Video",
   "description": "Twilio Video JavaScript Library",
-  "version": "2.22.2",
+  "version": "2.24.1",
   "homepage": "https://twilio.com",
   "author": "Mark Andrus Roberts <mroberts@twilio.com>",
   "contributors": [
@@ -135,7 +135,7 @@
     "test:framework:install": "npm install chromedriver && npm install selenium-webdriver && npm install geckodriver && npm install puppeteer",
     "test:framework": "npm-run-all test:framework:install test:framework:no-framework test:framework:react",
     "test": "npm-run-all test:unit test:integration",
-    "build:es5": "rimraf ./es5 && tsc tsdef/twilio-video-tests.ts --noEmit --lib es2018,dom && tsc ",
+    "build:es5": "rimraf ./es5 && mkdir -p es5 && tsc tsdef/twilio-video-tests.ts --noEmit --lib es2018,dom && tsc",
     "build:js": "node ./scripts/build.js ./src/twilio-video.js ./LICENSE.md ./dist/twilio-video.js",
     "build:min.js": "uglifyjs ./dist/twilio-video.js -o ./dist/twilio-video.min.js --comments \"/^! twilio-video.js/\" -b beautify=false,ascii_only=true",
     "build": "npm-run-all clean lint docs test:unit test:integration build:es5 build:js build:min.js test:umd",

package/tsconfig.json

@@ -7,6 +7,7 @@
     "lib": ["es2019", "dom"],
     "downlevelIteration": true,
     "module": "commonjs",
+    "moduleResolution": "node",
     "noImplicitAny": true,
     "noImplicitThis": true,
     "outDir": "./es5",