aliyun-rtc-sdk 7.1.0-beta.1 → 7.1.0

package/dist/plugins/beautyPlugin.d.ts

@@ -1,8 +1,918 @@
-import EventEmitter from 'eventemitter3';
-import { LocalStream, IProfile } from 'aliyun-rts-sdk';
-import { IVideoConstraints, IAudioConstraints } from 'media-device';
+import EventEmitter$1 from 'eventemitter3';
 import { QueenEngineWorker } from 'aliyun-queen-engine';
 
+interface IProfile {
+    width: number;
+    height: number;
+    frameRate: number;
+    maxBitrate: number;
+}
+interface IAudioProfile {
+    sampleRate: number;
+    channelCount: number;
+    maxBitrate: number;
+}
+
+declare enum FacingMode {
+    USER = "user",
+    ENVIRONMENT = "environment"
+}
+interface IError {
+    code: number;
+    reason: string;
+    relatedLink: string;
+}
+interface IAudioConstraints extends MediaTrackConstraints {
+}
+interface IVideoConstraints {
+    deviceId?: string;
+    facingMode?: FacingMode;
+    aspectRatio?: ConstrainDouble;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+}
+interface IScreenConstraints {
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+    preferCurrentTab?: boolean;
+    selfBrowserSurface?: string;
+    surfaceSwitching?: string;
+    systemAudio?: string;
+}
+interface IDeviceManager {
+    checkSupportScreenShare(): boolean;
+    getCameraList(): Promise<Array<MediaDeviceInfo>>;
+    getMicList(): Promise<Array<MediaDeviceInfo>>;
+    getSpeakerList(): Promise<Array<MediaDeviceInfo>>;
+    getAudioTrack(constraints: IAudioConstraints): Promise<MediaStreamTrack>;
+    getVideoTrack(constraints: IVideoConstraints): Promise<MediaStreamTrack>;
+    getScreenTrack(constraints: IScreenConstraints): Promise<MediaStreamTrack[]>;
+    getAudioStream(constraints: IAudioConstraints): Promise<MediaStream>;
+    getVideoStream(constraints: IVideoConstraints): Promise<MediaStream>;
+    getScreenStream(constraints: IScreenConstraints): Promise<MediaStream>;
+}
+
+declare class DeviceError implements IError {
+    code: number;
+    reason: string;
+    relatedLink: string;
+    private linkUtil;
+    constructor(errorCode: number, reason: string);
+    static isDeviceManagerError(error: unknown): error is IError;
+}
+
+declare class BrowserDeviceManager implements IDeviceManager {
+    private systemUtil;
+    private deviceManager;
+    static isDeviceManagerError: typeof DeviceError.isDeviceManagerError;
+    constructor();
+    getCameraList(): Promise<Array<MediaDeviceInfo>>;
+    getMicList(): Promise<Array<MediaDeviceInfo>>;
+    getSpeakerList(): Promise<Array<MediaDeviceInfo>>;
+    getAudioTrack(constraints: IAudioConstraints): Promise<MediaStreamTrack>;
+    getVideoTrack(constraints: IVideoConstraints): Promise<MediaStreamTrack>;
+    getScreenTrack(constraints: IScreenConstraints): Promise<MediaStreamTrack[]>;
+    getAudioStream(constraints: IAudioConstraints): Promise<MediaStream>;
+    getVideoStream(constraints: IVideoConstraints): Promise<MediaStream>;
+    getScreenStream(constraints: IScreenConstraints): Promise<MediaStream>;
+    checkSupportScreenShare(): boolean;
+    private createDeviceManager;
+}
+
+declare global {
+    interface Window {
+        BrowserDeviceManager: typeof BrowserDeviceManager;
+        define: any;
+    }
+}
+
+var parser = {};
+
+var grammar$1 = {exports: {}};
+
+var grammar = grammar$1.exports = {
+  v: [{
+    name: 'version',
+    reg: /^(\d*)$/
+  }],
+  o: [{
+    // o=- 20518 0 IN IP4 203.0.113.1
+    // NB: sessionId will be a String in most cases because it is huge
+    name: 'origin',
+    reg: /^(\S*) (\d*) (\d*) (\S*) IP(\d) (\S*)/,
+    names: ['username', 'sessionId', 'sessionVersion', 'netType', 'ipVer', 'address'],
+    format: '%s %s %d %s IP%d %s'
+  }],
+  // default parsing of these only (though some of these feel outdated)
+  s: [{ name: 'name' }],
+  i: [{ name: 'description' }],
+  u: [{ name: 'uri' }],
+  e: [{ name: 'email' }],
+  p: [{ name: 'phone' }],
+  z: [{ name: 'timezones' }], // TODO: this one can actually be parsed properly...
+  r: [{ name: 'repeats' }],   // TODO: this one can also be parsed properly
+  // k: [{}], // outdated thing ignored
+  t: [{
+    // t=0 0
+    name: 'timing',
+    reg: /^(\d*) (\d*)/,
+    names: ['start', 'stop'],
+    format: '%d %d'
+  }],
+  c: [{
+    // c=IN IP4 10.47.197.26
+    name: 'connection',
+    reg: /^IN IP(\d) (\S*)/,
+    names: ['version', 'ip'],
+    format: 'IN IP%d %s'
+  }],
+  b: [{
+    // b=AS:4000
+    push: 'bandwidth',
+    reg: /^(TIAS|AS|CT|RR|RS):(\d*)/,
+    names: ['type', 'limit'],
+    format: '%s:%s'
+  }],
+  m: [{
+    // m=video 51744 RTP/AVP 126 97 98 34 31
+    // NB: special - pushes to session
+    // TODO: rtp/fmtp should be filtered by the payloads found here?
+    reg: /^(\w*) (\d*) ([\w/]*)(?: (.*))?/,
+    names: ['type', 'port', 'protocol', 'payloads'],
+    format: '%s %d %s %s'
+  }],
+  a: [
+    {
+      // a=rtpmap:110 opus/48000/2
+      push: 'rtp',
+      reg: /^rtpmap:(\d*) ([\w\-.]*)(?:\s*\/(\d*)(?:\s*\/(\S*))?)?/,
+      names: ['payload', 'codec', 'rate', 'encoding'],
+      format: function (o) {
+        return (o.encoding)
+          ? 'rtpmap:%d %s/%s/%s'
+          : o.rate
+            ? 'rtpmap:%d %s/%s'
+            : 'rtpmap:%d %s';
+      }
+    },
+    {
+      // a=fmtp:108 profile-level-id=24;object=23;bitrate=64000
+      // a=fmtp:111 minptime=10; useinbandfec=1
+      push: 'fmtp',
+      reg: /^fmtp:(\d*) ([\S| ]*)/,
+      names: ['payload', 'config'],
+      format: 'fmtp:%d %s'
+    },
+    {
+      // a=control:streamid=0
+      name: 'control',
+      reg: /^control:(.*)/,
+      format: 'control:%s'
+    },
+    {
+      // a=rtcp:65179 IN IP4 193.84.77.194
+      name: 'rtcp',
+      reg: /^rtcp:(\d*)(?: (\S*) IP(\d) (\S*))?/,
+      names: ['port', 'netType', 'ipVer', 'address'],
+      format: function (o) {
+        return (o.address != null)
+          ? 'rtcp:%d %s IP%d %s'
+          : 'rtcp:%d';
+      }
+    },
+    {
+      // a=rtcp-fb:98 trr-int 100
+      push: 'rtcpFbTrrInt',
+      reg: /^rtcp-fb:(\*|\d*) trr-int (\d*)/,
+      names: ['payload', 'value'],
+      format: 'rtcp-fb:%s trr-int %d'
+    },
+    {
+      // a=rtcp-fb:98 nack rpsi
+      push: 'rtcpFb',
+      reg: /^rtcp-fb:(\*|\d*) ([\w-_]*)(?: ([\w-_]*))?/,
+      names: ['payload', 'type', 'subtype'],
+      format: function (o) {
+        return (o.subtype != null)
+          ? 'rtcp-fb:%s %s %s'
+          : 'rtcp-fb:%s %s';
+      }
+    },
+    {
+      // a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+      // a=extmap:1/recvonly URI-gps-string
+      // a=extmap:3 urn:ietf:params:rtp-hdrext:encrypt urn:ietf:params:rtp-hdrext:smpte-tc 25@600/24
+      push: 'ext',
+      reg: /^extmap:(\d+)(?:\/(\w+))?(?: (urn:ietf:params:rtp-hdrext:encrypt))? (\S*)(?: (\S*))?/,
+      names: ['value', 'direction', 'encrypt-uri', 'uri', 'config'],
+      format: function (o) {
+        return (
+          'extmap:%d' +
+          (o.direction ? '/%s' : '%v') +
+          (o['encrypt-uri'] ? ' %s' : '%v') +
+          ' %s' +
+          (o.config ? ' %s' : '')
+        );
+      }
+    },
+    {
+      // a=extmap-allow-mixed
+      name: 'extmapAllowMixed',
+      reg: /^(extmap-allow-mixed)/
+    },
+    {
+      // a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR|2^20|1:32
+      push: 'crypto',
+      reg: /^crypto:(\d*) ([\w_]*) (\S*)(?: (\S*))?/,
+      names: ['id', 'suite', 'config', 'sessionConfig'],
+      format: function (o) {
+        return (o.sessionConfig != null)
+          ? 'crypto:%d %s %s %s'
+          : 'crypto:%d %s %s';
+      }
+    },
+    {
+      // a=setup:actpass
+      name: 'setup',
+      reg: /^setup:(\w*)/,
+      format: 'setup:%s'
+    },
+    {
+      // a=connection:new
+      name: 'connectionType',
+      reg: /^connection:(new|existing)/,
+      format: 'connection:%s'
+    },
+    {
+      // a=mid:1
+      name: 'mid',
+      reg: /^mid:([^\s]*)/,
+      format: 'mid:%s'
+    },
+    {
+      // a=msid:0c8b064d-d807-43b4-b434-f92a889d8587 98178685-d409-46e0-8e16-7ef0db0db64a
+      name: 'msid',
+      reg: /^msid:(.*)/,
+      format: 'msid:%s'
+    },
+    {
+      // a=ptime:20
+      name: 'ptime',
+      reg: /^ptime:(\d*(?:\.\d*)*)/,
+      format: 'ptime:%d'
+    },
+    {
+      // a=maxptime:60
+      name: 'maxptime',
+      reg: /^maxptime:(\d*(?:\.\d*)*)/,
+      format: 'maxptime:%d'
+    },
+    {
+      // a=sendrecv
+      name: 'direction',
+      reg: /^(sendrecv|recvonly|sendonly|inactive)/
+    },
+    {
+      // a=ice-lite
+      name: 'icelite',
+      reg: /^(ice-lite)/
+    },
+    {
+      // a=ice-ufrag:F7gI
+      name: 'iceUfrag',
+      reg: /^ice-ufrag:(\S*)/,
+      format: 'ice-ufrag:%s'
+    },
+    {
+      // a=ice-pwd:x9cml/YzichV2+XlhiMu8g
+      name: 'icePwd',
+      reg: /^ice-pwd:(\S*)/,
+      format: 'ice-pwd:%s'
+    },
+    {
+      // a=fingerprint:SHA-1 00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33
+      name: 'fingerprint',
+      reg: /^fingerprint:(\S*) (\S*)/,
+      names: ['type', 'hash'],
+      format: 'fingerprint:%s %s'
+    },
+    {
+      // a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
+      // a=candidate:1162875081 1 udp 2113937151 192.168.34.75 60017 typ host generation 0 network-id 3 network-cost 10
+      // a=candidate:3289912957 2 udp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 generation 0 network-id 3 network-cost 10
+      // a=candidate:229815620 1 tcp 1518280447 192.168.150.19 60017 typ host tcptype active generation 0 network-id 3 network-cost 10
+      // a=candidate:3289912957 2 tcp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 tcptype passive generation 0 network-id 3 network-cost 10
+      push:'candidates',
+      reg: /^candidate:(\S*) (\d*) (\S*) (\d*) (\S*) (\d*) typ (\S*)(?: raddr (\S*) rport (\d*))?(?: tcptype (\S*))?(?: generation (\d*))?(?: network-id (\d*))?(?: network-cost (\d*))?/,
+      names: ['foundation', 'component', 'transport', 'priority', 'ip', 'port', 'type', 'raddr', 'rport', 'tcptype', 'generation', 'network-id', 'network-cost'],
+      format: function (o) {
+        var str = 'candidate:%s %d %s %d %s %d typ %s';
+
+        str += (o.raddr != null) ? ' raddr %s rport %d' : '%v%v';
+
+        // NB: candidate has three optional chunks, so %void middles one if it's missing
+        str += (o.tcptype != null) ? ' tcptype %s' : '%v';
+
+        if (o.generation != null) {
+          str += ' generation %d';
+        }
+
+        str += (o['network-id'] != null) ? ' network-id %d' : '%v';
+        str += (o['network-cost'] != null) ? ' network-cost %d' : '%v';
+        return str;
+      }
+    },
+    {
+      // a=end-of-candidates (keep after the candidates line for readability)
+      name: 'endOfCandidates',
+      reg: /^(end-of-candidates)/
+    },
+    {
+      // a=remote-candidates:1 203.0.113.1 54400 2 203.0.113.1 54401 ...
+      name: 'remoteCandidates',
+      reg: /^remote-candidates:(.*)/,
+      format: 'remote-candidates:%s'
+    },
+    {
+      // a=ice-options:google-ice
+      name: 'iceOptions',
+      reg: /^ice-options:(\S*)/,
+      format: 'ice-options:%s'
+    },
+    {
+      // a=ssrc:2566107569 cname:t9YU8M1UxTF8Y1A1
+      push: 'ssrcs',
+      reg: /^ssrc:(\d*) ([\w_-]*)(?::(.*))?/,
+      names: ['id', 'attribute', 'value'],
+      format: function (o) {
+        var str = 'ssrc:%d';
+        if (o.attribute != null) {
+          str += ' %s';
+          if (o.value != null) {
+            str += ':%s';
+          }
+        }
+        return str;
+      }
+    },
+    {
+      // a=ssrc-group:FEC 1 2
+      // a=ssrc-group:FEC-FR 3004364195 1080772241
+      push: 'ssrcGroups',
+      // token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 / %x41-5A / %x5E-7E
+      reg: /^ssrc-group:([\x21\x23\x24\x25\x26\x27\x2A\x2B\x2D\x2E\w]*) (.*)/,
+      names: ['semantics', 'ssrcs'],
+      format: 'ssrc-group:%s %s'
+    },
+    {
+      // a=msid-semantic: WMS Jvlam5X3SX1OP6pn20zWogvaKJz5Hjf9OnlV
+      name: 'msidSemantic',
+      reg: /^msid-semantic:\s?(\w*) (\S*)/,
+      names: ['semantic', 'token'],
+      format: 'msid-semantic: %s %s' // space after ':' is not accidental
+    },
+    {
+      // a=group:BUNDLE audio video
+      push: 'groups',
+      reg: /^group:(\w*) (.*)/,
+      names: ['type', 'mids'],
+      format: 'group:%s %s'
+    },
+    {
+      // a=rtcp-mux
+      name: 'rtcpMux',
+      reg: /^(rtcp-mux)/
+    },
+    {
+      // a=rtcp-rsize
+      name: 'rtcpRsize',
+      reg: /^(rtcp-rsize)/
+    },
+    {
+      // a=sctpmap:5000 webrtc-datachannel 1024
+      name: 'sctpmap',
+      reg: /^sctpmap:([\w_/]*) (\S*)(?: (\S*))?/,
+      names: ['sctpmapNumber', 'app', 'maxMessageSize'],
+      format: function (o) {
+        return (o.maxMessageSize != null)
+          ? 'sctpmap:%s %s %s'
+          : 'sctpmap:%s %s';
+      }
+    },
+    {
+      // a=x-google-flag:conference
+      name: 'xGoogleFlag',
+      reg: /^x-google-flag:([^\s]*)/,
+      format: 'x-google-flag:%s'
+    },
+    {
+      // a=rid:1 send max-width=1280;max-height=720;max-fps=30;depend=0
+      push: 'rids',
+      reg: /^rid:([\d\w]+) (\w+)(?: ([\S| ]*))?/,
+      names: ['id', 'direction', 'params'],
+      format: function (o) {
+        return (o.params) ? 'rid:%s %s %s' : 'rid:%s %s';
+      }
+    },
+    {
+      // a=imageattr:97 send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320] recv [x=330,y=250]
+      // a=imageattr:* send [x=800,y=640] recv *
+      // a=imageattr:100 recv [x=320,y=240]
+      push: 'imageattrs',
+      reg: new RegExp(
+        // a=imageattr:97
+        '^imageattr:(\\d+|\\*)' +
+        // send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320]
+        '[\\s\\t]+(send|recv)[\\s\\t]+(\\*|\\[\\S+\\](?:[\\s\\t]+\\[\\S+\\])*)' +
+        // recv [x=330,y=250]
+        '(?:[\\s\\t]+(recv|send)[\\s\\t]+(\\*|\\[\\S+\\](?:[\\s\\t]+\\[\\S+\\])*))?'
+      ),
+      names: ['pt', 'dir1', 'attrs1', 'dir2', 'attrs2'],
+      format: function (o) {
+        return 'imageattr:%s %s %s' + (o.dir2 ? ' %s %s' : '');
+      }
+    },
+    {
+      // a=simulcast:send 1,2,3;~4,~5 recv 6;~7,~8
+      // a=simulcast:recv 1;4,5 send 6;7
+      name: 'simulcast',
+      reg: new RegExp(
+        // a=simulcast:
+        '^simulcast:' +
+        // send 1,2,3;~4,~5
+        '(send|recv) ([a-zA-Z0-9\\-_~;,]+)' +
+        // space + recv 6;~7,~8
+        '(?:\\s?(send|recv) ([a-zA-Z0-9\\-_~;,]+))?' +
+        // end
+        '$'
+      ),
+      names: ['dir1', 'list1', 'dir2', 'list2'],
+      format: function (o) {
+        return 'simulcast:%s %s' + (o.dir2 ? ' %s %s' : '');
+      }
+    },
+    {
+      // old simulcast draft 03 (implemented by Firefox)
+      //   https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-03
+      // a=simulcast: recv pt=97;98 send pt=97
+      // a=simulcast: send rid=5;6;7 paused=6,7
+      name: 'simulcast_03',
+      reg: /^simulcast:[\s\t]+([\S+\s\t]+)$/,
+      names: ['value'],
+      format: 'simulcast: %s'
+    },
+    {
+      // a=framerate:25
+      // a=framerate:29.97
+      name: 'framerate',
+      reg: /^framerate:(\d+(?:$|\.\d+))/,
+      format: 'framerate:%s'
+    },
+    {
+      // RFC4570
+      // a=source-filter: incl IN IP4 239.5.2.31 10.1.15.5
+      name: 'sourceFilter',
+      reg: /^source-filter: *(excl|incl) (\S*) (IP4|IP6|\*) (\S*) (.*)/,
+      names: ['filterMode', 'netType', 'addressTypes', 'destAddress', 'srcList'],
+      format: 'source-filter: %s %s %s %s %s'
+    },
+    {
+      // a=bundle-only
+      name: 'bundleOnly',
+      reg: /^(bundle-only)/
+    },
+    {
+      // a=label:1
+      name: 'label',
+      reg: /^label:(.+)/,
+      format: 'label:%s'
+    },
+    {
+      // RFC version 26 for SCTP over DTLS
+      // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-5
+      name: 'sctpPort',
+      reg: /^sctp-port:(\d+)$/,
+      format: 'sctp-port:%s'
+    },
+    {
+      // RFC version 26 for SCTP over DTLS
+      // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-6
+      name: 'maxMessageSize',
+      reg: /^max-message-size:(\d+)$/,
+      format: 'max-message-size:%s'
+    },
+    {
+      // RFC7273
+      // a=ts-refclk:ptp=IEEE1588-2008:39-A7-94-FF-FE-07-CB-D0:37
+      push:'tsRefClocks',
+      reg: /^ts-refclk:([^\s=]*)(?:=(\S*))?/,
+      names: ['clksrc', 'clksrcExt'],
+      format: function (o) {
+        return 'ts-refclk:%s' + (o.clksrcExt != null ? '=%s' : '');
+      }
+    },
+    {
+      // RFC7273
+      // a=mediaclk:direct=963214424
+      name:'mediaClk',
+      reg: /^mediaclk:(?:id=(\S*))? *([^\s=]*)(?:=(\S*))?(?: *rate=(\d+)\/(\d+))?/,
+      names: ['id', 'mediaClockName', 'mediaClockValue', 'rateNumerator', 'rateDenominator'],
+      format: function (o) {
+        var str = 'mediaclk:';
+        str += (o.id != null ? 'id=%s %s' : '%v%s');
+        str += (o.mediaClockValue != null ? '=%s' : '');
+        str += (o.rateNumerator != null ? ' rate=%s' : '');
+        str += (o.rateDenominator != null ? '/%s' : '');
+        return str;
+      }
+    },
+    {
+      // a=keywds:keywords
+      name: 'keywords',
+      reg: /^keywds:(.+)$/,
+      format: 'keywds:%s'
+    },
+    {
+      // a=content:main
+      name: 'content',
+      reg: /^content:(.+)/,
+      format: 'content:%s'
+    },
+    // BFCP https://tools.ietf.org/html/rfc4583
+    {
+      // a=floorctrl:c-s
+      name: 'bfcpFloorCtrl',
+      reg: /^floorctrl:(c-only|s-only|c-s)/,
+      format: 'floorctrl:%s'
+    },
+    {
+      // a=confid:1
+      name: 'bfcpConfId',
+      reg: /^confid:(\d+)/,
+      format: 'confid:%s'
+    },
+    {
+      // a=userid:1
+      name: 'bfcpUserId',
+      reg: /^userid:(\d+)/,
+      format: 'userid:%s'
+    },
+    {
+      // a=floorid:1
+      name: 'bfcpFloorId',
+      reg: /^floorid:(.+) (?:m-stream|mstrm):(.+)/,
+      names: ['id', 'mStream'],
+      format: 'floorid:%s mstrm:%s'
+    },
+    {
+      // any a= that we don't understand is kept verbatim on media.invalid
+      push: 'invalid',
+      names: ['value']
+    }
+  ]
+};
+
+// set sensible defaults to avoid polluting the grammar with boring details
+Object.keys(grammar).forEach(function (key) {
+  var objs = grammar[key];
+  objs.forEach(function (obj) {
+    if (!obj.reg) {
+      obj.reg = /(.*)/;
+    }
+    if (!obj.format) {
+      obj.format = '%s';
+    }
+  });
+});
+
+var grammarExports = grammar$1.exports;
+
+(function (exports) {
+	var toIntIfInt = function (v) {
+	  return String(Number(v)) === v ? Number(v) : v;
+	};
+
+	var attachProperties = function (match, location, names, rawName) {
+	  if (rawName && !names) {
+	    location[rawName] = toIntIfInt(match[1]);
+	  }
+	  else {
+	    for (var i = 0; i < names.length; i += 1) {
+	      if (match[i+1] != null) {
+	        location[names[i]] = toIntIfInt(match[i+1]);
+	      }
+	    }
+	  }
+	};
+
+	var parseReg = function (obj, location, content) {
+	  var needsBlank = obj.name && obj.names;
+	  if (obj.push && !location[obj.push]) {
+	    location[obj.push] = [];
+	  }
+	  else if (needsBlank && !location[obj.name]) {
+	    location[obj.name] = {};
+	  }
+	  var keyLocation = obj.push ?
+	    {} :  // blank object that will be pushed
+	    needsBlank ? location[obj.name] : location; // otherwise, named location or root
+
+	  attachProperties(content.match(obj.reg), keyLocation, obj.names, obj.name);
+
+	  if (obj.push) {
+	    location[obj.push].push(keyLocation);
+	  }
+	};
+
+	var grammar = grammarExports;
+	var validLine = RegExp.prototype.test.bind(/^([a-z])=(.*)/);
+
+	exports.parse = function (sdp) {
+	  var session = {}
+	    , media = []
+	    , location = session; // points at where properties go under (one of the above)
+
+	  // parse lines we understand
+	  sdp.split(/(\r\n|\r|\n)/).filter(validLine).forEach(function (l) {
+	    var type = l[0];
+	    var content = l.slice(2);
+	    if (type === 'm') {
+	      media.push({rtp: [], fmtp: []});
+	      location = media[media.length-1]; // point at latest media line
+	    }
+
+	    for (var j = 0; j < (grammar[type] || []).length; j += 1) {
+	      var obj = grammar[type][j];
+	      if (obj.reg.test(content)) {
+	        return parseReg(obj, location, content);
+	      }
+	    }
+	  });
+
+	  session.media = media; // link it up
+	  return session;
+	};
+
+	var paramReducer = function (acc, expr) {
+	  var s = expr.split(/=(.+)/, 2);
+	  if (s.length === 2) {
+	    acc[s[0]] = toIntIfInt(s[1]);
+	  } else if (s.length === 1 && expr.length > 1) {
+	    acc[s[0]] = undefined;
+	  }
+	  return acc;
+	};
+
+	exports.parseParams = function (str) {
+	  return str.split(/;\s?/).reduce(paramReducer, {});
+	};
+
+	// For backward compatibility - alias will be removed in 3.0.0
+	exports.parseFmtpConfig = exports.parseParams;
+
+	exports.parsePayloads = function (str) {
+	  return str.toString().split(' ').map(Number);
+	};
+
+	exports.parseRemoteCandidates = function (str) {
+	  var candidates = [];
+	  var parts = str.split(' ').map(toIntIfInt);
+	  for (var i = 0; i < parts.length; i += 3) {
+	    candidates.push({
+	      component: parts[i],
+	      ip: parts[i + 1],
+	      port: parts[i + 2]
+	    });
+	  }
+	  return candidates;
+	};
+
+	exports.parseImageAttributes = function (str) {
+	  return str.split(' ').map(function (item) {
+	    return item.substring(1, item.length-1).split(',').reduce(paramReducer, {});
+	  });
+	};
+
+	exports.parseSimulcastStreamList = function (str) {
+	  return str.split(';').map(function (stream) {
+	    return stream.split(',').map(function (format) {
+	      var scid, paused = false;
+
+	      if (format[0] !== '~') {
+	        scid = toIntIfInt(format);
+	      } else {
+	        scid = toIntIfInt(format.substring(1, format.length));
+	        paused = true;
+	      }
+
+	      return {
+	        scid: scid,
+	        paused: paused
+	      };
+	    });
+	  });
+	}; 
+} (parser));
+
+interface IListenerMap {
+    [s: string]: any;
+}
+type MapToList<T, V extends keyof T> = {
+    [K in V]: T[K][];
+};
+declare class EventEmitter<T extends IListenerMap> {
+    _eventMap: MapToList<T, keyof T>;
+    listeners<K extends keyof T>(type: K): MapToList<T, keyof T>[K];
+    emit<K extends keyof T>(type: K, ...args: any[]): boolean;
+    off<K extends keyof T>(type: K, fn: T[K]): this;
+    removeAllListeners<K extends keyof T>(type?: K): this;
+    on<K extends keyof T>(type: K, fn: T[K]): this;
+    once<K extends keyof T>(type: K, fn: T[K]): this;
+}
+
+declare class Stream extends EventEmitter<IMediaEvent> {
+    protected audiotrack?: MediaStreamTrack;
+    protected videotrack?: MediaStreamTrack;
+    protected element?: HTMLMediaElement;
+    protected mediastream?: MediaStream;
+    protected traceid: string;
+    protected reporter?: IReporter;
+    id: string;
+    constructor();
+    set traceId(value: string);
+    get traceId(): string;
+    get mediaElement(): HTMLMediaElement | undefined;
+    setReporter(reporter: IReporter): void;
+    play(element: HTMLMediaElement): void;
+    stop(): void;
+}
+
+interface IAudioMixer {
+    trackList: MediaStreamTrack[];
+    useGainNode?: boolean;
+}
+declare class AudioMixer {
+    protected audioTrackArr: MediaStreamTrack[];
+    protected useGainNode: boolean;
+    protected audioContext: AudioContext;
+    protected audioDestination: MediaStreamAudioDestinationNode;
+    protected audioSource: MediaStreamAudioSourceNode[];
+    protected gainNode: GainNode | null;
+    protected audioTrack: MediaStreamTrack | null;
+    constructor(props: IAudioMixer);
+    destroy(): void;
+    updateTrackList(trackList: MediaStreamTrack[]): void;
+    getMixedAudioTrack(): MediaStreamTrack;
+    private connectNode;
+    private disconnectSourceNode;
+}
+
+interface IProps {
+    video: HTMLVideoElement;
+}
+declare class CanvasRenderer {
+    private activeRenderer;
+    private canvas;
+    private video;
+    private ms?;
+    constructor(props: IProps);
+    get mediaStream(): MediaStream;
+    start(): void;
+    stop(): void;
+    private initCanvas;
+    private initRenderer;
+    private render;
+    resize(width: number, height: number): void;
+}
+
+declare class LocalStream extends Stream {
+    protected deviceManager: BrowserDeviceManager;
+    protected mediastream: MediaStream;
+    protected videoProfile: string;
+    protected screenProfile: string;
+    protected audioProfile: string;
+    protected pc?: RTCPeerConnection;
+    protected audioMixer?: AudioMixer;
+    protected canvasRenderer?: CanvasRenderer;
+    micAudioTrack?: MediaStreamTrack;
+    screenAudioTrack?: MediaStreamTrack;
+    hasVideo: boolean;
+    hasScreen: boolean;
+    isCustomStream: boolean;
+    screenSurfaceType: string | undefined;
+    VideoProfileMap: Map<string, IProfile>;
+    ScreenProfileMap: Map<string, IProfile>;
+    AudioProfileMap: Map<string, IAudioProfile>;
+    constructor();
+    get mediaStream(): MediaStream;
+    get audioTrack(): MediaStreamTrack | undefined;
+    get videoTrack(): MediaStreamTrack | undefined;
+    get hasAudio(): boolean;
+    getVideoProfile(): string | undefined;
+    getScreenProfile(): string | undefined;
+    getAudioProfile(): string | undefined;
+    init(config: IStreamConfig): Promise<void>;
+    initWithRetry(config: IStreamConfig, res?: () => void, rej?: (reason?: any) => void): Promise<void>;
+    private initMicAudio;
+    private initCameraVideo;
+    private initScreenVideoAudio;
+    private tryMixMicAndScreenAudio;
+    private initTracks;
+    private tryToSetProfile;
+    private stopAllTracks;
+    private resetLocalStream;
+    setEncodeParam(pc: RTCPeerConnection, kind?: string): void;
+    private setVideoEncodeParams;
+    private setAudioEncodeParams;
+    play(element: HTMLVideoElement, config?: {
+        autoplay?: boolean;
+        canvasStream?: boolean;
+    }): void;
+    setVideoProfile(profile: string): Promise<unknown>;
+    setScreenProfile(profile: string): Promise<unknown>;
+    setAudioProfile(profile: string): Promise<unknown>;
+    enableAudio(): boolean;
+    disableAudio(): boolean;
+    enableVideo(): boolean;
+    disableVideo(): boolean;
+    stop(): void;
+    mergeStream(newStream: LocalStream): void;
+    deleteTracks(trackType: {
+        video?: boolean;
+        audio?: boolean;
+    }): void;
+    protected createCustomStream(stream?: MediaStream): Promise<void>;
+    protected releaseMediaStream(): void;
+    protected hasVideoTrackReady(config: IStreamConfig): boolean;
+    protected hasScreenAudioConfig(config: IStreamConfig): boolean | MediaTrackConstraints | undefined;
+    protected hasAudioTrackReady(config: IStreamConfig): boolean;
+    protected hasMicAudioAndReady(config: IStreamConfig): false | MediaStreamTrack | undefined;
+    protected hasScreenAudioAndReady(config: IStreamConfig): false | MediaStreamTrack | undefined;
+    protected addTrackListener(): void;
+    protected listenVideoEnded(): void;
+    private listenAudioEnded;
+    protected handleVideoTrackEnded(): void;
+    protected handleAudioTrackEnded(): void;
+}
+
+interface IStreamConfig {
+    audio?: IAudioConstraints | boolean;
+    video?: IVideoConstraints | boolean;
+    screen?: IScreenConstraints | boolean;
+    custom?: boolean;
+    mediaStream?: MediaStream;
+    skipProfile?: boolean;
+}
+interface IMediaEvent {
+    onAutoPlayError: () => void;
+    onCanPlay: () => void;
+    onReplaceTrack: () => void;
+    videoTrackEnded: () => void;
+    audioTrackEnded: () => void;
+    mediaElementBinded: () => void;
+    micAudioTrackEnded: () => void;
+    screenAudioTrackEnded: () => void;
+}
+interface IReporter {
+    reportVideoProfile(profile: string): void;
+    reportScreenProfile(profile: string): void;
+    reportAudioProfile(profile: string): void;
+    reportEnableAudio(): void;
+    reportDisableAudio(): void;
+    reportEnableVideo(): void;
+    reportDisableVideo(): void;
+    reportStop(type: number): void;
+    reportPlay(type: string): void;
+}
+
+declare global {
+    interface Window {
+        SystemUtil: any;
+        BrowserUtil: any;
+        Guid: any;
+        LocalStorage: any;
+        ApiRequest: any;
+        define: any;
+    }
+}
+
+declare global {
+    interface Window {
+        AliRTS: any;
+        define: any;
+        mozRTCPeerConnection: any;
+        webkitAudioContext: any;
+        WeixinJSBridge: any;
+    }
+    interface RTCConfiguration {
+        googCpuOveruseDetection?: boolean;
+    }
+    interface RTCRtpParameters {
+        encodings: RTCRtpEncodingParameters[];
+    }
+}
+
 declare enum AliRtcRawDataStreamType {
     /** 相机流 */
     AliRtcSdkStreamTypeCapture = 0,
@@ -37,7 +947,7 @@ interface AliRtcLocalStreamListener {
     videotrackended: () => void;
     audiotrackended: () => void;
 }
-declare class AliRtcLocalStreamInfo extends EventEmitter<AliRtcLocalStreamListener> {
+declare class AliRtcLocalStreamInfo extends EventEmitter$1<AliRtcLocalStreamListener> {
     type: AliRtcRawDataStreamType;
     originVideoTrack?: MediaStreamTrack;
     videoSource?: VideoStreamSource;
@@ -151,7 +1061,7 @@ interface AliRtcPluginListener {
     error: (error: any) => void;
     unsupported: () => void;
 }
-declare abstract class AliRtcPlugin extends EventEmitter<AliRtcPluginListener> {
+declare abstract class AliRtcPlugin extends EventEmitter$1<AliRtcPluginListener> {
     name: string;
     options: any;
     type: AliRtcPluginType;