@webex/internal-media-core 0.0.4-beta → 0.0.5-beta

package/dist/esm/index.js

@@ -2473,762 +2473,1204 @@ const getErrorDescription = (error) => {
     return error ? (error.stack ? `${error.message}: ${error.stack}` : `${error}`) : '';
 };
 
-var lib = {};
-
-var parser$1 = {};
-
-var grammar$2 = {exports: {}};
-
-var grammar$1 = grammar$2.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';
+const NUM = '\\d+';
+const TOKEN = '\\S+';
+const SP = '\\s';
+const REST = '.+';
 
-        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$1).forEach(function (key) {
-  var objs = grammar$1[key];
-  objs.forEach(function (obj) {
-    if (!obj.reg) {
-      obj.reg = /(.*)/;
-    }
-    if (!obj.format) {
-      obj.format = '%s';
-    }
-  });
-});
-
-(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 = grammar$2.exports;
-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)
+class Line {
+}
 
-  // 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
-    }
+var _a$5;
+class BandwidthLine extends Line {
+    constructor(bandwidthType, bandwidth) {
+        super();
+        this.bandwidthType = bandwidthType;
+        this.bandwidth = bandwidth;
+    }
+    static fromSdpLine(line) {
+        if (!BandwidthLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(BandwidthLine.regex);
+        const bandwidthType = tokens[1];
+        const bandwidth = parseInt(tokens[2], 10);
+        return new BandwidthLine(bandwidthType, bandwidth);
+    }
+    toSdpLine() {
+        return `b=${this.bandwidthType}:${this.bandwidth}`;
+    }
+}
+_a$5 = BandwidthLine;
+BandwidthLine.BW_TYPE_REGEX = 'CT|AS|TIAS';
+BandwidthLine.regex = new RegExp(`^(${_a$5.BW_TYPE_REGEX}):(${NUM})`);
+
+class BundleGroupLine extends Line {
+    constructor(mids) {
+        super();
+        this.mids = mids;
+    }
+    static fromSdpLine(line) {
+        if (!BundleGroupLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(BundleGroupLine.regex);
+        const mids = tokens[1].split(' ');
+        return new BundleGroupLine(mids);
+    }
+    toSdpLine() {
+        return `a=group:BUNDLE ${this.mids.join(' ')}`;
+    }
+}
+BundleGroupLine.regex = new RegExp(`^group:BUNDLE (${REST})`);
+
+var _a$4;
+class CandidateLine extends Line {
+    constructor(foundation, componentId, transport, priority, connectionAddress, port, candidateType, relAddr, relPort, candidateExtensions) {
+        super();
+        this.foundation = foundation;
+        this.componentId = componentId;
+        this.transport = transport;
+        this.priority = priority;
+        this.connectionAddress = connectionAddress;
+        this.port = port;
+        this.candidateType = candidateType;
+        this.relAddr = relAddr;
+        this.relPort = relPort;
+        this.candidateExtensions = candidateExtensions;
+    }
+    static fromSdpLine(line) {
+        if (!CandidateLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(CandidateLine.regex);
+        const foundation = tokens[1];
+        const componentId = parseInt(tokens[2], 10);
+        const transport = tokens[3];
+        const priority = parseInt(tokens[4], 10);
+        const connectionAddress = tokens[5];
+        const port = parseInt(tokens[6], 10);
+        const candidateType = tokens[7];
+        const relAddr = tokens[8];
+        const relPort = tokens[9] ? parseInt(tokens[9], 10) : undefined;
+        const candidateExtensions = tokens[10];
+        return new CandidateLine(foundation, componentId, transport, priority, connectionAddress, port, candidateType, relAddr, relPort, candidateExtensions);
+    }
+    toSdpLine() {
+        let str = '';
+        str += `a=candidate:${this.foundation} ${this.componentId} ${this.transport} ${this.priority} ${this.connectionAddress} ${this.port} typ ${this.candidateType}`;
+        if (this.relAddr) {
+            str += ` raddr ${this.relAddr}`;
+        }
+        if (this.relPort) {
+            str += ` rport ${this.relPort}`;
+        }
+        if (this.candidateExtensions) {
+            str += ` ${this.candidateExtensions}`;
+        }
+        return str;
+    }
+}
+_a$4 = CandidateLine;
+CandidateLine.ICE_CHARS = `[a-zA-Z0-9+/]+`;
+CandidateLine.regex = new RegExp(`^candidate:(${_a$4.ICE_CHARS}) (${NUM}) (${TOKEN}) (${NUM}) (${TOKEN}) (${NUM}) typ (${TOKEN})(?: raddr (${TOKEN}))?(?: rport (${NUM}))?(?: (${REST}))?`);
+
+class ConnectionLine extends Line {
+    constructor(netType, addrType, ipAddr) {
+        super();
+        this.netType = netType;
+        this.addrType = addrType;
+        this.ipAddr = ipAddr;
+    }
+    static fromSdpLine(line) {
+        if (!ConnectionLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(ConnectionLine.regex);
+        const netType = tokens[1];
+        const addrType = tokens[2];
+        const ipAddr = tokens[3];
+        return new ConnectionLine(netType, addrType, ipAddr);
+    }
+    toSdpLine() {
+        return `c=${this.netType} ${this.addrType} ${this.ipAddr}`;
+    }
+}
+ConnectionLine.regex = new RegExp(`^(${TOKEN}) (${TOKEN}) (${TOKEN})`);
 
-    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);
-      }
-    }
-  });
+class ContentLine extends Line {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    static fromSdpLine(line) {
+        if (!ContentLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(ContentLine.regex);
+        const values = tokens[1].split(',');
+        return new ContentLine(values);
+    }
+    toSdpLine() {
+        return `a=content:${this.values.join(',')}`;
+    }
+}
+ContentLine.regex = new RegExp(`^content:(${REST})$`);
 
-  session.media = media; // link it up
-  return session;
-};
+class DirectionLine extends Line {
+    constructor(direction) {
+        super();
+        this.direction = direction;
+    }
+    static fromSdpLine(line) {
+        if (!DirectionLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(DirectionLine.regex);
+        const direction = tokens[1];
+        return new DirectionLine(direction);
+    }
+    toSdpLine() {
+        return `a=${this.direction}`;
+    }
+}
+DirectionLine.regex = /^(sendrecv|sendonly|recvonly|inactive)$/;
+
+var _a$3;
+class ExtMapLine extends Line {
+    constructor(id, uri, direction, extensionAttributes) {
+        super();
+        this.id = id;
+        this.uri = uri;
+        this.direction = direction;
+        this.extensionAttributes = extensionAttributes;
+    }
+    static fromSdpLine(line) {
+        if (!ExtMapLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(ExtMapLine.regex);
+        const id = parseInt(tokens[1], 10);
+        const direction = tokens[2];
+        const uri = tokens[3];
+        const extensionAttributes = tokens[4];
+        return new ExtMapLine(id, uri, direction, extensionAttributes);
+    }
+    toSdpLine() {
+        let str = '';
+        str += `a=extmap:${this.id}`;
+        if (this.direction) {
+            str += `/${this.direction}`;
+        }
+        str += ` ${this.uri}`;
+        if (this.extensionAttributes) {
+            str += ` ${this.extensionAttributes}`;
+        }
+        return str;
+    }
+}
+_a$3 = ExtMapLine;
+ExtMapLine.EXTMAP_DIRECTION = `sendonly|recvonly|sendrecv|inactive`;
+ExtMapLine.regex = new RegExp(`^extmap:(${NUM})(?:/(${_a$3.EXTMAP_DIRECTION}))? (${TOKEN})(?: (${REST}))?`);
+
+class FingerprintLine extends Line {
+    constructor(fingerprint) {
+        super();
+        this.fingerprint = fingerprint;
+    }
+    static fromSdpLine(line) {
+        if (!FingerprintLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(FingerprintLine.regex);
+        const fingerprint = tokens[1];
+        return new FingerprintLine(fingerprint);
+    }
+    toSdpLine() {
+        return `a=fingerprint:${this.fingerprint}`;
+    }
+}
+FingerprintLine.regex = new RegExp(`^fingerprint:(${REST})`);
 
-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;
-};
+class FmtpLine extends Line {
+    constructor(payloadType, params) {
+        super();
+        this.payloadType = payloadType;
+        this.params = params;
+    }
+    static fromSdpLine(line) {
+        if (!FmtpLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(FmtpLine.regex);
+        const payloadType = parseInt(tokens[1], 10);
+        const params = tokens[2];
+        return new FmtpLine(payloadType, params);
+    }
+    toSdpLine() {
+        return `a=fmtp:${this.payloadType} ${this.params}`;
+    }
+}
+FmtpLine.regex = new RegExp(`^fmtp:(${NUM}) (${REST})`);
 
-exports.parseParams = function (str) {
-  return str.split(/;\s?/).reduce(paramReducer, {});
-};
+class IceOptionsLine extends Line {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    static fromSdpLine(line) {
+        if (!IceOptionsLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(IceOptionsLine.regex);
+        const options = tokens[1].split(' ');
+        return new IceOptionsLine(options);
+    }
+    toSdpLine() {
+        return `a=ice-options:${this.options.join(' ')}`;
+    }
+}
+IceOptionsLine.regex = new RegExp(`^ice-options:(${REST})$`);
 
-// For backward compatibility - alias will be removed in 3.0.0
-exports.parseFmtpConfig = exports.parseParams;
+class IcePwdLine extends Line {
+    constructor(pwd) {
+        super();
+        this.pwd = pwd;
+    }
+    static fromSdpLine(line) {
+        if (!IcePwdLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(IcePwdLine.regex);
+        const pwd = tokens[1];
+        return new IcePwdLine(pwd);
+    }
+    toSdpLine() {
+        return `a=ice-pwd:${this.pwd}`;
+    }
+}
+IcePwdLine.regex = new RegExp(`^ice-pwd:(${TOKEN})$`);
 
-exports.parsePayloads = function (str) {
-  return str.toString().split(' ').map(Number);
-};
+class IceUfragLine extends Line {
+    constructor(ufrag) {
+        super();
+        this.ufrag = ufrag;
+    }
+    static fromSdpLine(line) {
+        if (!IceUfragLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(IceUfragLine.regex);
+        const ufrag = tokens[1];
+        return new IceUfragLine(ufrag);
+    }
+    toSdpLine() {
+        return `a=ice-ufrag:${this.ufrag}`;
+    }
+}
+IceUfragLine.regex = new RegExp(`^ice-ufrag:(${TOKEN})$`);
 
-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;
-};
+class MaxMessageSizeLine extends Line {
+    constructor(maxMessageSize) {
+        super();
+        this.maxMessageSize = maxMessageSize;
+    }
+    static fromSdpLine(line) {
+        if (!MaxMessageSizeLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(MaxMessageSizeLine.regex);
+        const maxMessageSize = parseInt(tokens[1], 10);
+        return new MaxMessageSizeLine(maxMessageSize);
+    }
+    toSdpLine() {
+        return `a=max-message-size:${this.maxMessageSize}`;
+    }
+}
+MaxMessageSizeLine.regex = new RegExp(`^max-message-size:(${NUM})`);
+
+var _a$2;
+class MediaLine extends Line {
+    constructor(type, port, protocol, formats) {
+        super();
+        this.type = type;
+        this.port = port;
+        this.protocol = protocol;
+        this.formats = formats;
+    }
+    static fromSdpLine(line) {
+        if (!MediaLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(MediaLine.regex);
+        const type = tokens[1];
+        const port = parseInt(tokens[2], 10);
+        const protocol = tokens[3];
+        const formats = tokens[4].split(' ');
+        return new MediaLine(type, port, protocol, formats);
+    }
+    toSdpLine() {
+        return `m=${this.type} ${this.port} ${this.protocol} ${this.formats.join(' ')}`;
+    }
+}
+_a$2 = MediaLine;
+MediaLine.MEDIA_TYPE = 'audio|video|application';
+MediaLine.regex = new RegExp(`^(${_a$2.MEDIA_TYPE}) (${NUM}) (${TOKEN}) (${REST})`);
+
+class MidLine extends Line {
+    constructor(mid) {
+        super();
+        this.mid = mid;
+    }
+    static fromSdpLine(line) {
+        if (!MidLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(MidLine.regex);
+        const mid = tokens[1];
+        return new MidLine(mid);
+    }
+    toSdpLine() {
+        return `a=mid:${this.mid}`;
+    }
+}
+MidLine.regex = new RegExp(`^mid:(${TOKEN})$`);
+
+class OriginLine extends Line {
+    constructor(username, sessionId, sessionVersion, netType, addrType, ipAddr) {
+        super();
+        this.username = username;
+        this.sessionId = sessionId;
+        this.sessionVersion = sessionVersion;
+        this.netType = netType;
+        this.addrType = addrType;
+        this.ipAddr = ipAddr;
+    }
+    static fromSdpLine(line) {
+        if (!OriginLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(OriginLine.regex);
+        const username = tokens[1];
+        const sessionId = tokens[2];
+        const sessionVersion = parseInt(tokens[3], 10);
+        const netType = tokens[4];
+        const addrType = tokens[5];
+        const ipAddr = tokens[6];
+        return new OriginLine(username, sessionId, sessionVersion, netType, addrType, ipAddr);
+    }
+    toSdpLine() {
+        return `o=${this.username} ${this.sessionId} ${this.sessionVersion} ${this.netType} ${this.addrType} ${this.ipAddr}`;
+    }
+}
+OriginLine.regex = new RegExp(`^(${TOKEN}) (${TOKEN}) (${NUM}) (${TOKEN}) (${TOKEN}) (${TOKEN})`);
+
+var _a$1;
+class RidLine extends Line {
+    constructor(id, direction, params) {
+        super();
+        this.id = id;
+        this.direction = direction;
+        this.params = params;
+    }
+    static fromSdpLine(line) {
+        if (!RidLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(RidLine.regex);
+        const id = tokens[1];
+        const direction = tokens[2];
+        const params = tokens[3];
+        return new RidLine(id, direction, params);
+    }
+    toSdpLine() {
+        let str = '';
+        str += `a=rid:${this.id} ${this.direction}`;
+        if (this.params) {
+            str += ` ${this.params}`;
+        }
+        return str;
+    }
+}
+_a$1 = RidLine;
+RidLine.RID_ID = `[\\w-]+`;
+RidLine.RID_DIRECTION = `\\bsend\\b|\\brecv\\b`;
+RidLine.regex = new RegExp(`^rid:(${_a$1.RID_ID}) (${_a$1.RID_DIRECTION})(?:${SP}(${REST}))?`);
+
+class RtcpMuxLine extends Line {
+    static fromSdpLine(line) {
+        if (!RtcpMuxLine.regex.test(line)) {
+            return undefined;
+        }
+        return new RtcpMuxLine();
+    }
+    toSdpLine() {
+        return `a=rtcp-mux`;
+    }
+}
+RtcpMuxLine.regex = /^rtcp-mux$/;
 
-exports.parseImageAttributes = function (str) {
-  return str.split(' ').map(function (item) {
-    return item.substring(1, item.length-1).split(',').reduce(paramReducer, {});
-  });
-};
+class RtcpFbLine extends Line {
+    constructor(payloadType, feedback) {
+        super();
+        this.payloadType = payloadType;
+        this.feedback = feedback;
+    }
+    static fromSdpLine(line) {
+        if (!RtcpFbLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(RtcpFbLine.regex);
+        const payloadType = parseInt(tokens[1], 10);
+        const feedback = tokens[2];
+        return new RtcpFbLine(payloadType, feedback);
+    }
+    toSdpLine() {
+        return `a=rtcp-fb:${this.payloadType} ${this.feedback}`;
+    }
+}
+RtcpFbLine.regex = new RegExp(`^rtcp-fb:(${NUM}) (${REST})`);
+
+var _a$6;
+class RtpMapLine extends Line {
+    constructor(payloadType, encodingName, clockRate, encodingParams) {
+        super();
+        this.payloadType = payloadType;
+        this.encodingName = encodingName;
+        this.clockRate = clockRate;
+        this.encodingParams = encodingParams;
+    }
+    static fromSdpLine(line) {
+        if (!RtpMapLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(RtpMapLine.regex);
+        const payloadType = parseInt(tokens[1], 10);
+        const encodingName = tokens[2];
+        const clockRate = parseInt(tokens[3], 10);
+        const encodingParams = tokens[4];
+        return new RtpMapLine(payloadType, encodingName, clockRate, encodingParams);
+    }
+    toSdpLine() {
+        let str = '';
+        str += `a=rtpmap:${this.payloadType} ${this.encodingName}/${this.clockRate}`;
+        if (this.encodingParams) {
+            str += `/${this.encodingParams}`;
+        }
+        return str;
+    }
+}
+_a$6 = RtpMapLine;
+RtpMapLine.NON_SLASH_TOKEN = '[^\\s/]+';
+RtpMapLine.regex = new RegExp(`^rtpmap:(${NUM}) (${_a$6.NON_SLASH_TOKEN})/(${_a$6.NON_SLASH_TOKEN})(?:/(${_a$6.NON_SLASH_TOKEN}))?`);
+
+class SctpPortLine extends Line {
+    constructor(port) {
+        super();
+        this.port = port;
+    }
+    static fromSdpLine(line) {
+        if (!SctpPortLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(SctpPortLine.regex);
+        const port = parseInt(tokens[1], 10);
+        return new SctpPortLine(port);
+    }
+    toSdpLine() {
+        return `a=sctp-port:${this.port}`;
+    }
+}
+SctpPortLine.regex = new RegExp(`^sctp-port:(${NUM})`);
 
-exports.parseSimulcastStreamList = function (str) {
-  return str.split(';').map(function (stream) {
-    return stream.split(',').map(function (format) {
-      var scid, paused = false;
+class SessionInformationLine extends Line {
+    constructor(info) {
+        super();
+        this.info = info;
+    }
+    static fromSdpLine(line) {
+        if (!SessionInformationLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(SessionInformationLine.regex);
+        const info = tokens[1];
+        return new SessionInformationLine(info);
+    }
+    toSdpLine() {
+        return `i=${this.info}`;
+    }
+}
+SessionInformationLine.regex = new RegExp(`(${REST})`);
 
-      if (format[0] !== '~') {
-        scid = toIntIfInt(format);
-      } else {
-        scid = toIntIfInt(format.substring(1, format.length));
-        paused = true;
-      }
+class SessionNameLine extends Line {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    static fromSdpLine(line) {
+        if (!SessionNameLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(SessionNameLine.regex);
+        const name = tokens[1];
+        return new SessionNameLine(name);
+    }
+    toSdpLine() {
+        return `s=${this.name}`;
+    }
+}
+SessionNameLine.regex = new RegExp(`^(${REST})`);
 
-      return {
-        scid: scid,
-        paused: paused
-      };
-    });
-  });
-};
-}(parser$1));
-
-var grammar = grammar$2.exports;
-
-// customized util.format - discards excess arguments and can void middle ones
-var formatRegExp = /%[sdv%]/g;
-var format = function (formatStr) {
-  var i = 1;
-  var args = arguments;
-  var len = args.length;
-  return formatStr.replace(formatRegExp, function (x) {
-    if (i >= len) {
-      return x; // missing argument
-    }
-    var arg = args[i];
-    i += 1;
-    switch (x) {
-    case '%%':
-      return '%';
-    case '%s':
-      return String(arg);
-    case '%d':
-      return Number(arg);
-    case '%v':
-      return '';
-    }
-  });
-  // NB: we discard excess arguments - they are typically undefined from makeLine
-};
+class SetupLine extends Line {
+    constructor(setup) {
+        super();
+        this.setup = setup;
+    }
+    static fromSdpLine(line) {
+        if (!SetupLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(SetupLine.regex);
+        const setup = tokens[1];
+        return new SetupLine(setup);
+    }
+    toSdpLine() {
+        return `a=setup:${this.setup}`;
+    }
+}
+SetupLine.regex = /^setup:(actpass|active|passive)$/;
 
-var makeLine = function (type, obj, location) {
-  var str = obj.format instanceof Function ?
-    (obj.format(obj.push ? location : location[obj.name])) :
-    obj.format;
+class SimulcastLayer {
+    constructor(id, paused) {
+        this.id = id;
+        this.paused = paused;
+    }
+    toString() {
+        return this.paused ? `~${this.id}` : this.id;
+    }
+}
+class SimulcastLayerList {
+    constructor() {
+        this.layers = [];
+    }
+    addLayer(layer) {
+        this.layers.push([layer]);
+    }
+    addLayerWithAlternatives(alternatives) {
+        this.layers.push(alternatives);
+    }
+    get length() {
+        return this.layers.length;
+    }
+    get(index) {
+        return this.layers[index];
+    }
+    static fromString(str) {
+        const layerList = new SimulcastLayerList();
+        const tokens = str.split(';');
+        if (tokens.length === 1 && !tokens[0].trim()) {
+            throw new Error('simulcast stream list empty');
+        }
+        tokens.forEach((token) => {
+            if (!token) {
+                throw new Error('simulcast layer list empty');
+            }
+            const ridTokens = token.split(',');
+            const layers = [];
+            ridTokens.forEach((ridToken) => {
+                if (!ridToken || ridToken === '~') {
+                    throw new Error('rid empty');
+                }
+                const paused = ridToken[0] === '~';
+                const rid = paused ? ridToken.substring(1) : ridToken;
+                layers.push(new SimulcastLayer(rid, paused));
+            });
+            layerList.addLayerWithAlternatives(layers);
+        });
+        return layerList;
+    }
+    toString() {
+        return this.layers
+            .map((altArray) => altArray.map((v) => v.toString()).join(','))
+            .join(';');
+    }
+}
+class SimulcastLine extends Line {
+    constructor(sendLayers, recvLayers) {
+        super();
+        this.sendLayers = sendLayers;
+        this.recvLayers = recvLayers;
+    }
+    static fromSdpLine(line) {
+        if (!SimulcastLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(SimulcastLine.regex);
+        const bidirectional = tokens[3] && tokens[4];
+        const firstDirection = tokens[1];
+        const layerList1 = SimulcastLayerList.fromString(tokens[2]);
+        let layerList2 = new SimulcastLayerList();
+        if (bidirectional) {
+            const secondDirection = tokens[3];
+            if (firstDirection === secondDirection) {
+                return undefined;
+            }
+            layerList2 = SimulcastLayerList.fromString(tokens[4]);
+        }
+        let sendLayerList;
+        let recvLayerList;
+        if (firstDirection === 'send') {
+            sendLayerList = layerList1;
+            recvLayerList = layerList2;
+        }
+        else {
+            sendLayerList = layerList2;
+            recvLayerList = layerList1;
+        }
+        return new SimulcastLine(sendLayerList, recvLayerList);
+    }
+    toSdpLine() {
+        let str = 'a=simulcast:';
+        if (this.sendLayers.length) {
+            str += `send ${this.sendLayers.toString()}`;
+            if (this.recvLayers.length) {
+                str += ` `;
+            }
+        }
+        if (this.recvLayers.length) {
+            str += `recv ${this.recvLayers.toString()}`;
+        }
+        return str;
+    }
+}
+SimulcastLine.regex = new RegExp(`^simulcast:(send|recv) (${TOKEN})(?: (send|recv) (${TOKEN}))?`);
 
-  var args = [type + '=' + str];
-  if (obj.names) {
-    for (var i = 0; i < obj.names.length; i += 1) {
-      var n = obj.names[i];
-      if (obj.name) {
-        args.push(location[obj.name][n]);
-      }
-      else { // for mLine and push attributes
-        args.push(location[obj.names[i]]);
-      }
-    }
-  }
-  else {
-    args.push(location[obj.name]);
-  }
-  return format.apply(null, args);
-};
+class TimingLine extends Line {
+    constructor(startTime, stopTime) {
+        super();
+        this.startTime = startTime;
+        this.stopTime = stopTime;
+    }
+    static fromSdpLine(line) {
+        if (!TimingLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(TimingLine.regex);
+        const startTime = parseInt(tokens[1], 10);
+        const stopTime = parseInt(tokens[2], 10);
+        return new TimingLine(startTime, stopTime);
+    }
+    toSdpLine() {
+        return `t=${this.startTime} ${this.stopTime}`;
+    }
+}
+TimingLine.regex = new RegExp(`^(${NUM}) (${NUM})`);
 
-// RFC specified order
-// TODO: extend this with all the rest
-var defaultOuterOrder = [
-  'v', 'o', 's', 'i',
-  'u', 'e', 'p', 'c',
-  'b', 't', 'r', 'z', 'a'
-];
-var defaultInnerOrder = ['i', 'c', 'b', 'a'];
+class VersionLine extends Line {
+    constructor(version) {
+        super();
+        this.version = version;
+    }
+    static fromSdpLine(line) {
+        if (!VersionLine.regex.test(line)) {
+            return undefined;
+        }
+        const tokens = line.match(VersionLine.regex);
+        const version = parseInt(tokens[1], 10);
+        return new VersionLine(version);
+    }
+    toSdpLine() {
+        return `v=${this.version}`;
+    }
+}
+VersionLine.regex = new RegExp(`^(${NUM})$`);
 
+class UnknownLine extends Line {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    static fromSdpLine(line) {
+        const tokens = line.match(UnknownLine.regex);
+        const value = tokens[1];
+        return new UnknownLine(value);
+    }
+    toSdpLine() {
+        return `${this.value}`;
+    }
+}
+UnknownLine.regex = new RegExp(`(${REST})`);
 
-var writer$1 = function (session, opts) {
-  opts = opts || {};
-  // ensure certain properties exist
-  if (session.version == null) {
-    session.version = 0; // 'v=0' must be there (only defined version atm)
-  }
-  if (session.name == null) {
-    session.name = ' '; // 's= ' must be there if no meaningful name set
-  }
-  session.media.forEach(function (mLine) {
-    if (mLine.payloads == null) {
-      mLine.payloads = '';
-    }
-  });
+class IceInfo {
+    constructor() {
+        this.candidates = [];
+    }
+    addLine(line) {
+        if (line instanceof IceUfragLine) {
+            this.ufrag = line;
+            return true;
+        }
+        if (line instanceof IcePwdLine) {
+            this.pwd = line;
+            return true;
+        }
+        if (line instanceof IceOptionsLine) {
+            this.options = line;
+            return true;
+        }
+        if (line instanceof CandidateLine) {
+            this.candidates.push(line);
+            return true;
+        }
+        return false;
+    }
+    toLines() {
+        const lines = [];
+        if (this.ufrag) {
+            lines.push(this.ufrag);
+        }
+        if (this.pwd) {
+            lines.push(this.pwd);
+        }
+        if (this.options) {
+            lines.push(this.options);
+        }
+        this.candidates.forEach((candidate) => lines.push(candidate));
+        return lines;
+    }
+}
 
-  var outerOrder = opts.outerOrder || defaultOuterOrder;
-  var innerOrder = opts.innerOrder || defaultInnerOrder;
-  var sdp = [];
+class MediaDescription {
+    constructor(type, port, protocol) {
+        this.iceInfo = new IceInfo();
+        this.otherLines = [];
+        this.type = type;
+        this.port = port;
+        this.protocol = protocol;
+    }
+    findOtherLine(ty) {
+        return this.otherLines.find((line) => line instanceof ty);
+    }
+    addLine(line) {
+        if (line instanceof BundleGroupLine) {
+            throw new Error(`Error: bundle group line not allowed in media description`);
+        }
+        if (line instanceof BandwidthLine) {
+            this.bandwidth = line;
+            return true;
+        }
+        if (line instanceof MidLine) {
+            this.mid = line.mid;
+            return true;
+        }
+        if (line instanceof FingerprintLine) {
+            this.fingerprint = line.fingerprint;
+            return true;
+        }
+        if (line instanceof SetupLine) {
+            this.setup = line.setup;
+            return true;
+        }
+        if (line instanceof ConnectionLine) {
+            this.connection = line;
+            return true;
+        }
+        if (line instanceof ContentLine) {
+            this.content = line;
+            return true;
+        }
+        return this.iceInfo.addLine(line);
+    }
+}
 
-  // loop through outerOrder for matching properties on session
-  outerOrder.forEach(function (type) {
-    grammar[type].forEach(function (obj) {
-      if (obj.name in session && session[obj.name] != null) {
-        sdp.push(makeLine(type, obj, session));
-      }
-      else if (obj.push in session && session[obj.push] != null) {
-        session[obj.push].forEach(function (el) {
-          sdp.push(makeLine(type, obj, el));
-        });
-      }
-    });
-  });
+class ApplicationMediaDescription extends MediaDescription {
+    constructor(mediaLine) {
+        super(mediaLine.type, mediaLine.port, mediaLine.protocol);
+        this.fmts = [];
+        this.fmts = mediaLine.formats;
+    }
+    toLines() {
+        const lines = [];
+        lines.push(new MediaLine(this.type, this.port, this.protocol, this.fmts));
+        if (this.connection) {
+            lines.push(this.connection);
+        }
+        if (this.bandwidth) {
+            lines.push(this.bandwidth);
+        }
+        lines.push(...this.iceInfo.toLines());
+        if (this.fingerprint) {
+            lines.push(new FingerprintLine(this.fingerprint));
+        }
+        if (this.setup) {
+            lines.push(new SetupLine(this.setup));
+        }
+        if (this.mid) {
+            lines.push(new MidLine(this.mid));
+        }
+        if (this.content) {
+            lines.push(this.content);
+        }
+        if (this.sctpPort) {
+            lines.push(new SctpPortLine(this.sctpPort));
+        }
+        if (this.maxMessageSize) {
+            lines.push(new MaxMessageSizeLine(this.maxMessageSize));
+        }
+        lines.push(...this.otherLines);
+        return lines;
+    }
+    addLine(line) {
+        if (super.addLine(line)) {
+            return true;
+        }
+        if (line instanceof MediaLine) {
+            throw new Error('Error: tried passing a MediaLine to an existing MediaInfo');
+        }
+        if (line instanceof SctpPortLine) {
+            this.sctpPort = line.port;
+            return true;
+        }
+        if (line instanceof MaxMessageSizeLine) {
+            this.maxMessageSize = line.maxMessageSize;
+            return true;
+        }
+        this.otherLines.push(line);
+        return true;
+    }
+}
 
-  // then for each media line, follow the innerOrder
-  session.media.forEach(function (mLine) {
-    sdp.push(makeLine('m', grammar.m[0], mLine));
+class CodecInfo {
+    constructor(pt) {
+        this.fmtParams = [];
+        this.feedback = [];
+        this.pt = pt;
+    }
+    addLine(line) {
+        if (line instanceof RtpMapLine) {
+            this.name = line.encodingName;
+            this.clockRate = line.clockRate;
+            this.encodingParams = line.encodingParams;
+            return true;
+        }
+        if (line instanceof FmtpLine) {
+            this.fmtParams.push(line.params);
+            if (line.params.indexOf('apt') !== -1) {
+                const apt = line.params.split('=')[1];
+                this.primaryCodecPt = parseInt(apt, 10);
+            }
+            return true;
+        }
+        if (line instanceof RtcpFbLine) {
+            this.feedback.push(line.feedback);
+            return true;
+        }
+        return false;
+    }
+    toLines() {
+        const lines = [];
+        lines.push(new RtpMapLine(this.pt, this.name, this.clockRate, this.encodingParams));
+        this.feedback.forEach((fb) => {
+            lines.push(new RtcpFbLine(this.pt, fb));
+        });
+        this.fmtParams.forEach((fmt) => {
+            lines.push(new FmtpLine(this.pt, fmt));
+        });
+        return lines;
+    }
+}
 
-    innerOrder.forEach(function (type) {
-      grammar[type].forEach(function (obj) {
-        if (obj.name in mLine && mLine[obj.name] != null) {
-          sdp.push(makeLine(type, obj, mLine));
-        }
-        else if (obj.push in mLine && mLine[obj.push] != null) {
-          mLine[obj.push].forEach(function (el) {
-            sdp.push(makeLine(type, obj, el));
-          });
-        }
-      });
-    });
-  });
+class AvMediaDescription extends MediaDescription {
+    constructor(mediaLine) {
+        super(mediaLine.type, mediaLine.port, mediaLine.protocol);
+        this.pts = [];
+        this.extMaps = [];
+        this.rids = [];
+        this.codecs = new Map();
+        this.rtcpMux = false;
+        this.pts = mediaLine.formats.map((fmt) => {
+            return parseInt(fmt, 10);
+        });
+        this.pts.forEach((pt) => this.codecs.set(pt, new CodecInfo(pt)));
+    }
+    toLines() {
+        const lines = [];
+        lines.push(new MediaLine(this.type, this.port, this.protocol, this.pts.map((pt) => `${pt}`)));
+        if (this.connection) {
+            lines.push(this.connection);
+        }
+        if (this.bandwidth) {
+            lines.push(this.bandwidth);
+        }
+        lines.push(...this.iceInfo.toLines());
+        if (this.fingerprint) {
+            lines.push(new FingerprintLine(this.fingerprint));
+        }
+        if (this.setup) {
+            lines.push(new SetupLine(this.setup));
+        }
+        if (this.mid) {
+            lines.push(new MidLine(this.mid));
+        }
+        if (this.rtcpMux) {
+            lines.push(new RtcpMuxLine());
+        }
+        if (this.content) {
+            lines.push(this.content);
+        }
+        this.extMaps.forEach((extMap) => lines.push(extMap));
+        this.rids.forEach((rid) => lines.push(rid));
+        if (this.simulcast) {
+            lines.push(this.simulcast);
+        }
+        if (this.direction) {
+            lines.push(new DirectionLine(this.direction));
+        }
+        this.codecs.forEach((codec) => lines.push(...codec.toLines()));
+        lines.push(...this.otherLines);
+        return lines;
+    }
+    addLine(line) {
+        if (super.addLine(line)) {
+            return true;
+        }
+        if (line instanceof MediaLine) {
+            throw new Error('Error: tried passing a MediaLine to an existing MediaInfo');
+        }
+        if (line instanceof DirectionLine) {
+            this.direction = line.direction;
+            return true;
+        }
+        if (line instanceof ExtMapLine) {
+            this.extMaps.push(line);
+            return true;
+        }
+        if (line instanceof RidLine) {
+            this.rids.push(line);
+            return true;
+        }
+        if (line instanceof RtcpMuxLine) {
+            this.rtcpMux = true;
+            return true;
+        }
+        if (line instanceof SimulcastLine) {
+            this.simulcast = line;
+            return true;
+        }
+        if (line instanceof RtpMapLine || line instanceof FmtpLine || line instanceof RtcpFbLine) {
+            const codec = this.codecs.get(line.payloadType);
+            if (!codec) {
+                throw new Error(`Error: got line for unknown codec: ${line.toSdpLine()}`);
+            }
+            codec.addLine(line);
+            return true;
+        }
+        this.otherLines.push(line);
+        return true;
+    }
+    getCodecByPt(pt) {
+        return this.codecs.get(pt);
+    }
+    removePt(pt) {
+        const associatedPts = [...this.codecs.values()]
+            .filter((ci) => ci.primaryCodecPt === pt)
+            .map((ci) => ci.pt);
+        const allPtsToRemove = [pt, ...associatedPts];
+        allPtsToRemove.forEach((ptToRemove) => {
+            this.codecs.delete(ptToRemove);
+        });
+        this.pts = this.pts.filter((existingPt) => allPtsToRemove.indexOf(existingPt) === -1);
+    }
+}
 
-  return sdp.join('\r\n') + '\r\n';
-};
+class SessionDescription {
+    constructor() {
+        this.groups = [];
+        this.otherLines = [];
+    }
+    addLine(line) {
+        if (line instanceof VersionLine) {
+            this.version = line;
+            return true;
+        }
+        if (line instanceof OriginLine) {
+            this.origin = line;
+            return true;
+        }
+        if (line instanceof SessionNameLine) {
+            this.sessionName = line;
+            return true;
+        }
+        if (line instanceof SessionInformationLine) {
+            this.information = line;
+            return true;
+        }
+        if (line instanceof TimingLine) {
+            this.timing = line;
+            return true;
+        }
+        if (line instanceof ConnectionLine) {
+            this.connection = line;
+            return true;
+        }
+        if (line instanceof BandwidthLine) {
+            this.bandwidth = line;
+            return true;
+        }
+        if (line instanceof BundleGroupLine) {
+            this.groups.push(line);
+            return true;
+        }
+        this.otherLines.push(line);
+        return true;
+    }
+    toLines() {
+        const lines = [];
+        if (this.version) {
+            lines.push(this.version);
+        }
+        if (this.origin) {
+            lines.push(this.origin);
+        }
+        if (this.sessionName) {
+            lines.push(this.sessionName);
+        }
+        if (this.information) {
+            lines.push(this.information);
+        }
+        if (this.connection) {
+            lines.push(this.connection);
+        }
+        if (this.bandwidth) {
+            lines.push(this.bandwidth);
+        }
+        if (this.timing) {
+            lines.push(this.timing);
+        }
+        if (this.groups) {
+            lines.push(...this.groups);
+        }
+        lines.push(...this.otherLines);
+        return lines;
+    }
+}
 
-var parser = parser$1;
-var writer = writer$1;
+class Sdp {
+    constructor() {
+        this.session = new SessionDescription();
+        this.media = [];
+    }
+    get avMedia() {
+        return this.media.filter((mi) => mi instanceof AvMediaDescription);
+    }
+    toString() {
+        const lines = [];
+        lines.push(...this.session.toLines());
+        this.media.forEach((m) => lines.push(...m.toLines()));
+        return `${lines.map((l) => l.toSdpLine()).join('\r\n')}\r\n`;
+    }
+}
 
-lib.write = writer;
-lib.parse = parser.parse;
-lib.parseParams = parser.parseParams;
-lib.parseFmtpConfig = parser.parseFmtpConfig; // Alias of parseParams().
-lib.parsePayloads = parser.parsePayloads;
-lib.parseRemoteCandidates = parser.parseRemoteCandidates;
-lib.parseImageAttributes = parser.parseImageAttributes;
-lib.parseSimulcastStreamList = parser.parseSimulcastStreamList;
+class Grammar {
+    constructor() {
+        this.parsers = new Map();
+    }
+    addParser(lineType, parser) {
+        const parsers = this.parsers.get(lineType) || [];
+        parsers.push(parser);
+        this.parsers.set(lineType, parsers);
+    }
+    getParsers(lineType) {
+        return this.parsers.get(lineType) || [];
+    }
+}
+class SdpGrammar extends Grammar {
+    constructor() {
+        super();
+        this.addParser('v', VersionLine.fromSdpLine);
+        this.addParser('o', OriginLine.fromSdpLine);
+        this.addParser('c', ConnectionLine.fromSdpLine);
+        this.addParser('i', SessionInformationLine.fromSdpLine);
+        this.addParser('m', MediaLine.fromSdpLine);
+        this.addParser('s', SessionNameLine.fromSdpLine);
+        this.addParser('t', TimingLine.fromSdpLine);
+        this.addParser('b', BandwidthLine.fromSdpLine);
+        this.addParser('a', RtpMapLine.fromSdpLine);
+        this.addParser('a', RtcpFbLine.fromSdpLine);
+        this.addParser('a', FmtpLine.fromSdpLine);
+        this.addParser('a', DirectionLine.fromSdpLine);
+        this.addParser('a', ExtMapLine.fromSdpLine);
+        this.addParser('a', MidLine.fromSdpLine);
+        this.addParser('a', IceUfragLine.fromSdpLine);
+        this.addParser('a', IcePwdLine.fromSdpLine);
+        this.addParser('a', IceOptionsLine.fromSdpLine);
+        this.addParser('a', FingerprintLine.fromSdpLine);
+        this.addParser('a', SetupLine.fromSdpLine);
+        this.addParser('a', SctpPortLine.fromSdpLine);
+        this.addParser('a', MaxMessageSizeLine.fromSdpLine);
+        this.addParser('a', RtcpMuxLine.fromSdpLine);
+        this.addParser('a', BundleGroupLine.fromSdpLine);
+        this.addParser('a', ContentLine.fromSdpLine);
+        this.addParser('a', RidLine.fromSdpLine);
+        this.addParser('a', CandidateLine.fromSdpLine);
+        this.addParser('a', SimulcastLine.fromSdpLine);
+    }
+}
+const DefaultSdpGrammar = new SdpGrammar();
+function isValidLine(line) {
+    return line.length > 2;
+}
+function parseToModel(lines) {
+    const sdp = new Sdp();
+    let currBlock = sdp.session;
+    lines.forEach((l) => {
+        if (l instanceof MediaLine) {
+            let mediaInfo;
+            if (l.type === 'audio' || l.type === 'video') {
+                mediaInfo = new AvMediaDescription(l);
+            }
+            else if (l.type === 'application') {
+                mediaInfo = new ApplicationMediaDescription(l);
+            }
+            else {
+                throw new Error(`Unhandled media type: ${l.type}`);
+            }
+            sdp.media.push(mediaInfo);
+            currBlock = mediaInfo;
+        }
+        else {
+            currBlock.addLine(l);
+        }
+    });
+    return sdp;
+}
+function parseToLines(sdp, grammar) {
+    const lines = [];
+    sdp
+        .split(/(\r\n|\r|\n)/)
+        .filter(isValidLine)
+        .forEach((l) => {
+        const lineType = l[0];
+        const lineValue = l.slice(2);
+        const parsers = grammar.getParsers(lineType);
+        for (const parser of parsers) {
+            const result = parser(lineValue);
+            if (result) {
+                lines.push(result);
+                return;
+            }
+        }
+        const result = UnknownLine.fromSdpLine(l);
+        lines.push(result);
+    });
+    return lines;
+}
+function parse(sdp, grammar = DefaultSdpGrammar) {
+    const lines = parseToLines(sdp, grammar);
+    const parsed = parseToModel(lines);
+    return parsed;
+}
 
-const SDP_CARRIAGE_RETURN = '\r\n';
 function getLocalTrackInfo(kind, receive, localTrack) {
     const direction = (() => {
         const send = !!localTrack;
@@ -3242,13 +3684,21 @@ function getLocalTrackInfo(kind, receive, localTrack) {
     })();
     return { trackOrKind: localTrack || kind, direction };
 }
+function hasH264Codec(mediaLine) {
+    for (const codec of mediaLine.codecs.values()) {
+        if (codec.name?.toUpperCase() === 'H264') {
+            return true;
+        }
+    }
+    return false;
+}
 function isSdpInvalid(options, errorLog, sdp) {
     if (!sdp) {
         return 'iceCandidate: SDP missing';
     }
-    const parsedSdp = lib.parse(sdp);
-    for (const mediaLine of parsedSdp.media) {
-        if (!mediaLine.candidates || mediaLine.candidates?.length === 0) {
+    const parsedSdp = parse(sdp);
+    for (const mediaLine of parsedSdp.avMedia) {
+        if (!mediaLine.iceInfo.candidates.length) {
             errorLog('isSdpInvalid', `ice candidates missing for m-line with mid=${mediaLine.mid}`);
             return 'isSdpInvalid: ice candidates missing';
         }
@@ -3256,46 +3706,147 @@ function isSdpInvalid(options, errorLog, sdp) {
             errorLog('isSdpInvalid', `Found invalid port number 0 at m-line with mid=${mediaLine.mid}`);
             return 'isSdpInvalid: Found invalid port number 0';
         }
-        if (!mediaLine.icePwd || !mediaLine.iceUfrag) {
+        if (!mediaLine.iceInfo.pwd || !mediaLine.iceInfo.ufrag) {
             errorLog('isSdpInvalid', `ice ufrag and password not found for m-line with mid=${mediaLine.mid}`);
             return 'isSdpInvalid: ice ufrag and password not found';
         }
+        if (options.requireH264 && mediaLine.type === 'video' && !hasH264Codec(mediaLine)) {
+            errorLog('isSdpInvalid', `H264 codec is missing for video media description with mid=${mediaLine.mid}`);
+            return 'isSdpInvalid: H264 codec is missing';
+        }
     }
     return '';
 }
-function convertCLineToIpv4(sdp) {
-    return sdp.replace(/c=IN IP6 .*/gi, 'c=IN IP4 0.0.0.0');
+function convertCLineToIPv4(sdp) {
+    const convertConnectionProp = (connection) => {
+        if (connection?.addrType === 'IP6') {
+            connection.addrType = 'IP4';
+            connection.ipAddr = '0.0.0.0';
+        }
+    };
+    convertConnectionProp(sdp.session.connection);
+    sdp.media.forEach((media) => {
+        convertConnectionProp(media.connection);
+    });
 }
 function convertPort9to0(sdp) {
-    return sdp.replace(/^m=(audio|video) 9 /gim, 'm=$1 0 ');
-}
-function getNumOfOccurences(string, subString) {
-    let n = 0;
-    let pos = 0;
-    while (pos >= 0) {
-        pos = string.indexOf(subString, pos);
-        if (pos >= 0) {
-            n += 1;
-            pos += subString.length;
+    sdp.media.forEach((media) => {
+        if (media.port === 9) {
+            media.port = 0;
         }
-    }
-    return n;
+    });
 }
 function setContentSlides(sdp) {
-    if (getNumOfOccurences(sdp, 'm=video ') === 2) {
-        return `${sdp}a=content:slides${SDP_CARRIAGE_RETURN}`;
+    const videoMediaDescriptions = sdp.avMedia.filter((media) => media.type === 'video');
+    if (videoMediaDescriptions.length === 2) {
+        videoMediaDescriptions[1].addLine(new ContentLine(['slides']));
+    }
+}
+class AnyLine extends Line {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    static fromSdpLine() {
+        return undefined;
+    }
+    toSdpLine() {
+        return `a=${this.value}`;
+    }
+}
+function addBandwidthLimits(sdp, limits) {
+    sdp.avMedia.forEach((media) => {
+        if (media.type === 'audio') {
+            media.addLine(new BandwidthLine('TIAS', limits.audio));
+        }
+        else if (media.type === 'video') {
+            media.addLine(new BandwidthLine('TIAS', limits.video));
+        }
+    });
+}
+function addPeriodicKeyframes(sdp, value) {
+    sdp.avMedia.forEach((media) => {
+        if (media.type === 'video') {
+            media.addLine(new AnyLine(`periodic-keyframes:${value}`));
+        }
+    });
+}
+function disableExtmap(sdp) {
+    sdp.avMedia.forEach((media) => {
+        media.extMaps.length = 0;
+    });
+}
+function appendToH264fmtpParams(sdp, paramsToAppend) {
+    sdp.avMedia.forEach((media) => {
+        if (media.type === 'video') {
+            media.codecs.forEach((codec) => {
+                if (codec.name?.toUpperCase() === 'H264') {
+                    codec.fmtParams = codec.fmtParams.map((fmtp) => `${fmtp};${paramsToAppend}`);
+                }
+            });
+        }
+    });
+}
+function setH264MaxFs(sdp, maxFsValue) {
+    appendToH264fmtpParams(sdp, `max-fs=${maxFsValue}`);
+}
+function disableRtx(sdp) {
+    sdp.avMedia.forEach((media) => {
+        const payloadTypesToRemove = [];
+        media.codecs.forEach((codec, codecPt) => {
+            if (codec.name === 'rtx' && codec.primaryCodecPt) {
+                payloadTypesToRemove.push(codecPt);
+            }
+        });
+        payloadTypesToRemove.forEach((pt) => media.codecs.delete(pt));
+        media.pts = media.pts.filter((pt) => !payloadTypesToRemove.includes(pt));
+    });
+}
+function mungeLocalSdpForBrowser(config, sdp) {
+    const parsedSdp = parse(sdp);
+    if (config.disableRtx) {
+        disableRtx(parsedSdp);
     }
-    return sdp;
+    return parsedSdp.toString();
 }
 function mungeLocalSdp(config, sdp) {
-    let mungedSdp = convertCLineToIpv4(sdp);
+    const parsedSdp = parse(sdp);
+    if (config.convertCLineToIPv4) {
+        convertCLineToIPv4(parsedSdp);
+    }
+    if (config.bandwidthLimits) {
+        addBandwidthLimits(parsedSdp, config.bandwidthLimits);
+    }
+    if (config.periodicKeyframes) {
+        addPeriodicKeyframes(parsedSdp, config.periodicKeyframes);
+    }
     if (config.convertPort9to0) {
-        mungedSdp = convertPort9to0(mungedSdp);
+        convertPort9to0(parsedSdp);
     }
     if (config.addContentSlides) {
-        mungedSdp = setContentSlides(mungedSdp);
+        setContentSlides(parsedSdp);
+    }
+    if (config.disableExtmap) {
+        disableExtmap(parsedSdp);
+    }
+    if (config.h264MaxFs) {
+        setH264MaxFs(parsedSdp, config.h264MaxFs);
+    }
+    return parsedSdp.toString();
+}
+function setStartBitrate(sdp, startBitrate) {
+    appendToH264fmtpParams(sdp, `x-google-start-bitrate=${startBitrate}`);
+}
+function mungeRemoteSdp(config, sdp) {
+    const parsedSdp = parse(sdp);
+    if (config.startBitrate) {
+        setStartBitrate(parsedSdp, config.startBitrate);
     }
-    return mungedSdp;
+    if (config.disableExtmap) {
+        disableExtmap(parsedSdp);
+    }
+    return parsedSdp.toString();
 }
 
 var Event$1;
@@ -3600,11 +4151,15 @@ class MediaConnection$1 extends EventEmitter {
             .createOffer()
             .then((description) => {
             this.log('createLocalOffer', 'local SDP offer created');
-            return this.pc.setLocalDescription(description);
+            const mungedDescription = {
+                type: description.type,
+                sdp: mungeLocalSdpForBrowser(this.config.sdpMunging, description?.sdp || ''),
+            };
+            return this.pc.setLocalDescription(mungedDescription);
         })
             .then(() => this.waitForIceCandidates())
             .then(() => {
-            const mungedSdp = mungeLocalSdp(this.config.sdpMunging, this.pc.localDescription.sdp);
+            const mungedSdp = mungeLocalSdp(this.config.sdpMunging, this.pc.localDescription?.sdp || '');
             return { sdp: mungedSdp };
         });
     }
@@ -3613,17 +4168,24 @@ class MediaConnection$1 extends EventEmitter {
         if (!sdp) {
             return Promise.reject(new Error('SDP missing'));
         }
+        const mungedRemoteSdp = mungeRemoteSdp(this.config.sdpMunging, sdp);
         return this.pc
             .setRemoteDescription(new window.RTCSessionDescription({
             type: 'offer',
-            sdp,
+            sdp: mungedRemoteSdp,
         }))
             .then(() => this.pc.createAnswer())
-            .then((answer) => this.pc.setLocalDescription(answer))
+            .then((answer) => {
+            const mungedAnswer = {
+                type: answer.type,
+                sdp: mungeLocalSdpForBrowser(this.config.sdpMunging, answer?.sdp || ''),
+            };
+            return this.pc.setLocalDescription(mungedAnswer);
+        })
             .then(() => this.waitForIceCandidates())
             .then(() => {
-            const mungedSdp = mungeLocalSdp(this.config.sdpMunging, this.pc.localDescription.sdp);
-            return { sdp: mungedSdp };
+            const mungedLocalSdp = mungeLocalSdp(this.config.sdpMunging, this.pc.localDescription?.sdp || '');
+            return { sdp: mungedLocalSdp };
         });
     }
     handleRemoteAnswer(sdp) {
@@ -3631,9 +4193,10 @@ class MediaConnection$1 extends EventEmitter {
         if (!sdp) {
             return Promise.reject(new Error('SDP missing'));
         }
+        const mungedRemoteSdp = mungeRemoteSdp(this.config.sdpMunging, sdp);
         return this.pc.setRemoteDescription(new window.RTCSessionDescription({
             type: 'answer',
-            sdp,
+            sdp: mungedRemoteSdp,
         }));
     }
     waitForIceCandidates() {
@@ -3642,6 +4205,7 @@ class MediaConnection$1 extends EventEmitter {
             let done = false;
             const isLocalSdpValid = () => !isSdpInvalid({
                 allowPort0: !!this.config.sdpMunging.convertPort9to0,
+                requireH264: !!this.config.requireH264,
             }, this.error.bind(this), this.pc.localDescription?.sdp);
             const doneGatheringIceCandidates = () => {
                 if (!done) {
@@ -3662,6 +4226,7 @@ class MediaConnection$1 extends EventEmitter {
             if (this.pc.iceGatheringState === 'complete' && isLocalSdpValid()) {
                 this.log('waitForIceCandidates()', 'iceGatheringState is already "complete" and local SDP is valid');
                 resolve();
+                return;
             }
             this.log('waitForIceCandidates()', 'waiting for ICE candidates to be gathered...');
             this.pc.onicegatheringstatechange = () => {
@@ -12524,6 +13089,19 @@ async function enableBNR(track) {
                 action: 'enableBNR()',
                 description: 'BNR module is present already',
             });
+            const oldDestinationTrack = bnrProcessor.destinationTrack;
+            if (track.id === oldDestinationTrack.id) {
+                const oldTrackErrorMsg = 'BNR is enabled on the track already';
+                const oldTrackError = new Error(oldTrackErrorMsg);
+                logger.error({
+                    ID: track.id,
+                    mediaType: MEDIA_STREAM_TRACK,
+                    action: 'enableBNR()',
+                    description: oldTrackErrorMsg,
+                    error: oldTrackError,
+                });
+                throw oldTrackError;
+            }
             logger.info({
                 ID: track.id,
                 mediaType: MEDIA_STREAM_TRACK,
@@ -12552,6 +13130,7 @@ async function enableBNR(track) {
         });
         const destinationStream = bnrProcessor.destinationStream.stream;
         const [destinationTrack] = destinationStream.getAudioTracks();
+        bnrProcessor.destinationTrack = destinationTrack;
         return destinationTrack;
     }
     catch (error) {
@@ -12609,6 +13188,7 @@ function disableBNR() {
         delete bnrProcessor.audioContext;
         delete bnrProcessor.sourceNode;
         delete bnrProcessor.destinationStream;
+        delete bnrProcessor.destinationTrack;
         return track;
     }
     catch (error) {