From 3c87a375c395fd51744417d622431ee48d2b09ff Mon Sep 17 00:00:00 2001
From: Mustafa Yontar <mustafa@oyd.org.tr>
Date: Tue, 7 Apr 2020 23:30:57 +0300
Subject: [PATCH] inital 2

---
 package-lock.json             |  183 ++
 package.json                  |   15 +-
 public/index.html             |    2 +
 src/App.vue                   |   71 +-
 src/assets/logo.svg           |    1 +
 src/components/HelloWorld.vue |  197 +-
 src/lib/RemoteFeed.vue        |  124 ++
 src/lib/VueJanus.vue          |  279 +++
 src/lib/adapter.js            | 2664 +++++++++++++++++++++++++
 src/lib/janus.js              | 3456 +++++++++++++++++++++++++++++++++
 src/main.js                   |   10 +-
 src/plugins/axios.js          |   62 +
 src/plugins/janus.js          |   21 +
 src/plugins/vuetify.js        |   23 +
 vue.config.js                 |    5 +
 15 files changed, 7038 insertions(+), 75 deletions(-)
 create mode 100644 src/assets/logo.svg
 create mode 100644 src/lib/RemoteFeed.vue
 create mode 100644 src/lib/VueJanus.vue
 create mode 100644 src/lib/adapter.js
 create mode 100644 src/lib/janus.js
 create mode 100644 src/plugins/axios.js
 create mode 100644 src/plugins/janus.js
 create mode 100644 src/plugins/vuetify.js
 create mode 100644 vue.config.js

diff --git a/package-lock.json b/package-lock.json
index 4403d99..60ce4ae 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2083,6 +2083,48 @@
       "integrity": "sha512-wMHVg2EOHaMRxbzgFJ9gtjOOCrI80OHLG14rxi28XwOW8ux6IiEbRCGGGqCtdAIg4FQCbW20k9RsT4y3gJlFug==",
       "dev": true
     },
+    "axios": {
+      "version": "0.18.1",
+      "resolved": "https://registry.npm.taobao.org/axios/download/axios-0.18.1.tgz",
+      "integrity": "sha1-/z8N4ue10YDnV62YAA8Qgbh7zqM=",
+      "dev": true,
+      "requires": {
+        "follow-redirects": "1.5.10",
+        "is-buffer": "^2.0.2"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npm.taobao.org/debug/download/debug-3.1.0.tgz?cache=0&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2Fdebug%2Fdownload%2Fdebug-3.1.0.tgz",
+          "integrity": "sha1-W7WgZyYotkFJVmuhaBnmFRjGcmE=",
+          "dev": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "follow-redirects": {
+          "version": "1.5.10",
+          "resolved": "https://registry.npm.taobao.org/follow-redirects/download/follow-redirects-1.5.10.tgz",
+          "integrity": "sha1-e3qfmuov3/NnhqlP9kPtB/T/Xio=",
+          "dev": true,
+          "requires": {
+            "debug": "=3.1.0"
+          }
+        },
+        "is-buffer": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npm.taobao.org/is-buffer/download/is-buffer-2.0.4.tgz",
+          "integrity": "sha1-PlcvI8hBGlz9lVfISeNmXgspBiM=",
+          "dev": true
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npm.taobao.org/ms/download/ms-2.0.0.tgz",
+          "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+          "dev": true
+        }
+      }
+    },
     "babel-eslint": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/babel-eslint/-/babel-eslint-10.1.0.tgz",
@@ -2954,6 +2996,17 @@
       "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=",
       "dev": true
     },
+    "clone-deep": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npm.taobao.org/clone-deep/download/clone-deep-4.0.1.tgz",
+      "integrity": "sha1-wZ/Zvbv4WUK0/ZechNz31fB8I4c=",
+      "dev": true,
+      "requires": {
+        "is-plain-object": "^2.0.4",
+        "kind-of": "^6.0.2",
+        "shallow-clone": "^3.0.0"
+      }
+    },
     "coa": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/coa/-/coa-2.0.2.tgz",
@@ -6467,6 +6520,12 @@
         }
       }
     },
+    "interpret": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npm.taobao.org/interpret/download/interpret-1.2.0.tgz",
+      "integrity": "sha1-1QYaYiS+WOgIOYX1AU2EQ1lXYpY=",
+      "dev": true
+    },
     "invariant": {
       "version": "2.2.4",
       "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz",
@@ -6845,6 +6904,11 @@
         }
       }
     },
+    "jquery": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.4.1.tgz",
+      "integrity": "sha512-36+AdBzCL+y6qjw5Tx7HgzeGCzC81MDDgaUP8ld2zhx58HdqXGoBd+tHdrBMiyjGQs0Hxs/MLZTu/eHNJJuWPw=="
+    },
     "js-message": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/js-message/-/js-message-1.0.5.tgz",
@@ -9188,6 +9252,15 @@
         "readable-stream": "^2.0.2"
       }
     },
+    "rechoir": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npm.taobao.org/rechoir/download/rechoir-0.6.2.tgz",
+      "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
+      "dev": true,
+      "requires": {
+        "resolve": "^1.1.6"
+      }
+    },
     "regenerate": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.0.tgz",
@@ -9513,6 +9586,14 @@
         "inherits": "^2.0.1"
       }
     },
+    "rtcpeerconnection-shim": {
+      "version": "1.2.15",
+      "resolved": "https://registry.npmjs.org/rtcpeerconnection-shim/-/rtcpeerconnection-shim-1.2.15.tgz",
+      "integrity": "sha512-C6DxhXt7bssQ1nHb154lqeL0SXz5Dx4RczXZu2Aa/L1NJFnEVDxFwCBo3fqtuljhHIGceg5JKBV4XJ0gW5JKyw==",
+      "requires": {
+        "sdp": "^2.6.0"
+      }
+    },
     "run-async": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.0.tgz",
@@ -9561,6 +9642,36 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "dev": true
     },
+    "sass": {
+      "version": "1.26.3",
+      "resolved": "https://registry.npm.taobao.org/sass/download/sass-1.26.3.tgz?cache=0&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2Fsass%2Fdownload%2Fsass-1.26.3.tgz",
+      "integrity": "sha1-QS31RIYUO3a1plzfdWnob0Rln0Y=",
+      "dev": true,
+      "requires": {
+        "chokidar": ">=2.0.0 <4.0.0"
+      }
+    },
+    "sass-loader": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npm.taobao.org/sass-loader/download/sass-loader-8.0.2.tgz?cache=0&sync_timestamp=1578921506275&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2Fsass-loader%2Fdownload%2Fsass-loader-8.0.2.tgz",
+      "integrity": "sha1-3r7NjDziQ8dkVPLoKQSCFQOACQ0=",
+      "dev": true,
+      "requires": {
+        "clone-deep": "^4.0.1",
+        "loader-utils": "^1.2.3",
+        "neo-async": "^2.6.1",
+        "schema-utils": "^2.6.1",
+        "semver": "^6.3.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npm.taobao.org/semver/download/semver-6.3.0.tgz?cache=0&sync_timestamp=1581458146669&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2Fsemver%2Fdownload%2Fsemver-6.3.0.tgz",
+          "integrity": "sha1-7gpkyK9ejO6mdoexM3YeG+y9HT0=",
+          "dev": true
+        }
+      }
+    },
     "sax": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
@@ -9577,6 +9688,11 @@
         "ajv-keywords": "^3.4.1"
       }
     },
+    "sdp": {
+      "version": "2.12.0",
+      "resolved": "https://registry.npmjs.org/sdp/-/sdp-2.12.0.tgz",
+      "integrity": "sha512-jhXqQAQVM+8Xj5EjJGVweuEzgtGWb3tmEEpl3CLP3cStInSbVHSg0QWOGQzNq8pSID4JkpeV2mPqlMDLrm0/Vw=="
+    },
     "select-hose": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz",
@@ -9775,6 +9891,15 @@
         "safe-buffer": "^5.0.1"
       }
     },
+    "shallow-clone": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npm.taobao.org/shallow-clone/download/shallow-clone-3.0.1.tgz",
+      "integrity": "sha1-jymBrZJTH1UDWwH7IwdppA4C76M=",
+      "dev": true,
+      "requires": {
+        "kind-of": "^6.0.2"
+      }
+    },
     "shebang-command": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
@@ -9796,6 +9921,17 @@
       "integrity": "sha512-mRz/m/JVscCrkMyPqHc/bczi3OQHkLTqXHEFu0zDhK/qfv3UcOA4SVmRCLmos4bhjr9ekVQubj/R7waKapmiQg==",
       "dev": true
     },
+    "shelljs": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npm.taobao.org/shelljs/download/shelljs-0.8.3.tgz",
+      "integrity": "sha1-p/MxlSDr8J7oEnWyNorbKGZZsJc=",
+      "dev": true,
+      "requires": {
+        "glob": "^7.0.0",
+        "interpret": "^1.0.0",
+        "rechoir": "^0.6.2"
+      }
+    },
     "signal-exit": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
@@ -11075,6 +11211,30 @@
       "resolved": "https://registry.npmjs.org/vue/-/vue-2.6.11.tgz",
       "integrity": "sha512-VfPwgcGABbGAue9+sfrD4PuwFar7gPb1yl1UK1MwXoQPAw0BKSqWfoYCT/ThFrdEVWoI51dBuyCoiNU9bZDZxQ=="
     },
+    "vue-cli-plugin-axios": {
+      "version": "0.0.4",
+      "resolved": "https://registry.npm.taobao.org/vue-cli-plugin-axios/download/vue-cli-plugin-axios-0.0.4.tgz",
+      "integrity": "sha1-KdTrSCdcf+FbkuH9XZX74qlmQ28=",
+      "dev": true
+    },
+    "vue-cli-plugin-vuetify": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npm.taobao.org/vue-cli-plugin-vuetify/download/vue-cli-plugin-vuetify-2.0.5.tgz",
+      "integrity": "sha1-Cbp4koZT/H44Aeo35RIPlXQT3aQ=",
+      "dev": true,
+      "requires": {
+        "semver": "^7.1.2",
+        "shelljs": "^0.8.3"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.1.3",
+          "resolved": "https://registry.npm.taobao.org/semver/download/semver-7.1.3.tgz?cache=0&sync_timestamp=1581458146669&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2Fsemver%2Fdownload%2Fsemver-7.1.3.tgz",
+          "integrity": "sha1-5DRc5zBxxT8zZEXPwZ77HDEd8qY=",
+          "dev": true
+        }
+      }
+    },
     "vue-eslint-parser": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/vue-eslint-parser/-/vue-eslint-parser-7.0.0.tgz",
@@ -11162,6 +11322,20 @@
       "integrity": "sha512-4gDntzrifFnCEvyoO8PqyJDmguXgVPxKiIxrBKjIowvL9l+N66196+72XVYR8BBf1Uv1Fgt3bGevJ+sEmxfZzw==",
       "dev": true
     },
+    "vuetify": {
+      "version": "2.2.20",
+      "resolved": "https://registry.npm.taobao.org/vuetify/download/vuetify-2.2.20.tgz",
+      "integrity": "sha1-jLBC9ydPORMPjUDYXSPWLRwzyuQ="
+    },
+    "vuetify-loader": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npm.taobao.org/vuetify-loader/download/vuetify-loader-1.4.3.tgz",
+      "integrity": "sha1-3xMjxVi+CYkId+X76BezpxpsU40=",
+      "dev": true,
+      "requires": {
+        "loader-utils": "^1.2.0"
+      }
+    },
     "watchpack": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.6.0.tgz",
@@ -11516,6 +11690,15 @@
         }
       }
     },
+    "webrtc-adapter": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-7.5.1.tgz",
+      "integrity": "sha512-R5LkIR/APjODkstSXFOztOmINXQ0nqIGfUoKTtCzjyiDXHNgwhkqZ9vi8UzGyjfUBibuZ0ZzVyV10qtuLGW3CQ==",
+      "requires": {
+        "rtcpeerconnection-shim": "^1.2.15",
+        "sdp": "^2.12.0"
+      }
+    },
     "websocket-driver": {
       "version": "0.7.3",
       "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.3.tgz",
diff --git a/package.json b/package.json
index b51058e..b6b6336 100644
--- a/package.json
+++ b/package.json
@@ -3,22 +3,31 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "serve": "vue-cli-service serve",
+    "serve": "vue-cli-service serve  --port 8091",
     "build": "vue-cli-service build",
     "lint": "vue-cli-service lint"
   },
   "dependencies": {
     "core-js": "^3.6.4",
-    "vue": "^2.6.11"
+    "jquery": "^3.4.1",
+    "vue": "^2.6.11",
+    "vuetify": "^2.2.11",
+    "webrtc-adapter": "^7.5.1"
   },
   "devDependencies": {
     "@vue/cli-plugin-babel": "~4.2.0",
     "@vue/cli-plugin-eslint": "~4.2.0",
     "@vue/cli-service": "~4.2.0",
+    "axios": "^0.18.0",
     "babel-eslint": "^10.0.3",
     "eslint": "^6.7.2",
     "eslint-plugin-vue": "^6.1.2",
-    "vue-template-compiler": "^2.6.11"
+    "sass": "^1.19.0",
+    "sass-loader": "^8.0.0",
+    "vue-cli-plugin-axios": "0.0.4",
+    "vue-cli-plugin-vuetify": "~2.0.5",
+    "vue-template-compiler": "^2.6.11",
+    "vuetify-loader": "^1.3.0"
   },
   "eslintConfig": {
     "root": true,
diff --git a/public/index.html b/public/index.html
index 4123528..bc51465 100644
--- a/public/index.html
+++ b/public/index.html
@@ -6,6 +6,8 @@
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <link rel="icon" href="<%= BASE_URL %>favicon.ico">
     <title><%= htmlWebpackPlugin.options.title %></title>
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@mdi/font@latest/css/materialdesignicons.min.css">
   </head>
   <body>
     <noscript>
diff --git a/src/App.vue b/src/App.vue
index 55df315..236aeaa 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -1,28 +1,63 @@
 <template>
-  <div id="app">
-    <img alt="Vue logo" src="./assets/logo.png">
-    <HelloWorld msg="Welcome to Your Vue.js App"/>
-  </div>
+  <v-app>
+    <v-app-bar
+      app
+      color="primary"
+      dark
+    >
+      <div class="d-flex align-center">
+        <v-img
+          alt="Vuetify Logo"
+          class="shrink mr-2"
+          contain
+          src="https://cdn.vuetifyjs.com/images/logos/vuetify-logo-dark.png"
+          transition="scale-transition"
+          width="40"
+        />
+
+        <v-img
+          alt="Vuetify Name"
+          class="shrink mt-1 hidden-sm-and-down"
+          contain
+          min-width="100"
+          src="https://cdn.vuetifyjs.com/images/logos/vuetify-name-dark.png"
+          width="100"
+        />
+      </div>
+
+      <v-spacer></v-spacer>
+
+      <v-btn
+        href="https://github.com/vuetifyjs/vuetify/releases/latest"
+        target="_blank"
+        text
+      >
+        <span class="mr-2">Latest Release</span>
+        <v-icon>mdi-open-in-new</v-icon>
+      </v-btn>
+    </v-app-bar>
+
+    <v-content>
+      <VueJanus server="https://vid.w3ic.org/janus" :room="room" username="vuettest"/>
+    </v-content>
+  </v-app>
 </template>
 
 <script>
-import HelloWorld from './components/HelloWorld.vue'
+import VueJanus from "@/lib/VueJanus";
 
 export default {
   name: 'App',
+
   components: {
-    HelloWorld
+    VueJanus
+  },
+
+  data: () => ({
+    test: ' ',
+    room:1234
+  }),
+  mounted () {
   }
-}
+};
 </script>
-
-<style>
-#app {
-  font-family: Avenir, Helvetica, Arial, sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  text-align: center;
-  color: #2c3e50;
-  margin-top: 60px;
-}
-</style>
diff --git a/src/assets/logo.svg b/src/assets/logo.svg
new file mode 100644
index 0000000..145b6d1
--- /dev/null
+++ b/src/assets/logo.svg
@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 87.5 100"><defs><style>.cls-1{fill:#1697f6;}.cls-2{fill:#7bc6ff;}.cls-3{fill:#1867c0;}.cls-4{fill:#aeddff;}</style></defs><title>Artboard 46</title><polyline class="cls-1" points="43.75 0 23.31 0 43.75 48.32"/><polygon class="cls-2" points="43.75 62.5 43.75 100 0 14.58 22.92 14.58 43.75 62.5"/><polyline class="cls-3" points="43.75 0 64.19 0 43.75 48.32"/><polygon class="cls-4" points="64.58 14.58 87.5 14.58 43.75 100 43.75 62.5 64.58 14.58"/></svg>
diff --git a/src/components/HelloWorld.vue b/src/components/HelloWorld.vue
index 879051a..099f437 100644
--- a/src/components/HelloWorld.vue
+++ b/src/components/HelloWorld.vue
@@ -1,58 +1,151 @@
 <template>
-  <div class="hello">
-    <h1>{{ msg }}</h1>
-    <p>
-      For a guide and recipes on how to configure / customize this project,<br>
-      check out the
-      <a href="https://cli.vuejs.org" target="_blank" rel="noopener">vue-cli documentation</a>.
-    </p>
-    <h3>Installed CLI Plugins</h3>
-    <ul>
-      <li><a href="https://github.com/vuejs/vue-cli/tree/dev/packages/%40vue/cli-plugin-babel" target="_blank" rel="noopener">babel</a></li>
-      <li><a href="https://github.com/vuejs/vue-cli/tree/dev/packages/%40vue/cli-plugin-eslint" target="_blank" rel="noopener">eslint</a></li>
-    </ul>
-    <h3>Essential Links</h3>
-    <ul>
-      <li><a href="https://vuejs.org" target="_blank" rel="noopener">Core Docs</a></li>
-      <li><a href="https://forum.vuejs.org" target="_blank" rel="noopener">Forum</a></li>
-      <li><a href="https://chat.vuejs.org" target="_blank" rel="noopener">Community Chat</a></li>
-      <li><a href="https://twitter.com/vuejs" target="_blank" rel="noopener">Twitter</a></li>
-      <li><a href="https://news.vuejs.org" target="_blank" rel="noopener">News</a></li>
-    </ul>
-    <h3>Ecosystem</h3>
-    <ul>
-      <li><a href="https://router.vuejs.org" target="_blank" rel="noopener">vue-router</a></li>
-      <li><a href="https://vuex.vuejs.org" target="_blank" rel="noopener">vuex</a></li>
-      <li><a href="https://github.com/vuejs/vue-devtools#vue-devtools" target="_blank" rel="noopener">vue-devtools</a></li>
-      <li><a href="https://vue-loader.vuejs.org" target="_blank" rel="noopener">vue-loader</a></li>
-      <li><a href="https://github.com/vuejs/awesome-vue" target="_blank" rel="noopener">awesome-vue</a></li>
-    </ul>
-  </div>
+  <v-container>
+    <v-row class="text-center">
+      <v-col cols="12">
+        <v-img
+          :src="require('../assets/logo.svg')"
+          class="my-3"
+          contain
+          height="200"
+        />
+      </v-col>
+
+      <v-col class="mb-4">
+        <h1 class="display-2 font-weight-bold mb-3">
+          Welcome to Vuetify
+        </h1>
+
+        <p class="subheading font-weight-regular">
+          For help and collaboration with other Vuetify developers,
+          <br>please join our online
+          <a
+            href="https://community.vuetifyjs.com"
+            target="_blank"
+          >Discord Community</a>
+        </p>
+      </v-col>
+
+      <v-col
+        class="mb-5"
+        cols="12"
+      >
+        <h2 class="headline font-weight-bold mb-3">
+          What's next?
+        </h2>
+
+        <v-row justify="center">
+          <a
+            v-for="(next, i) in whatsNext"
+            :key="i"
+            :href="next.href"
+            class="subheading mx-3"
+            target="_blank"
+          >
+            {{ next.text }}
+          </a>
+        </v-row>
+      </v-col>
+
+      <v-col
+        class="mb-5"
+        cols="12"
+      >
+        <h2 class="headline font-weight-bold mb-3">
+          Important Links
+        </h2>
+
+        <v-row justify="center">
+          <a
+            v-for="(link, i) in importantLinks"
+            :key="i"
+            :href="link.href"
+            class="subheading mx-3"
+            target="_blank"
+          >
+            {{ link.text }}
+          </a>
+        </v-row>
+      </v-col>
+
+      <v-col
+        class="mb-5"
+        cols="12"
+      >
+        <h2 class="headline font-weight-bold mb-3">
+          Ecosystem
+        </h2>
+
+        <v-row justify="center">
+          <a
+            v-for="(eco, i) in ecosystem"
+            :key="i"
+            :href="eco.href"
+            class="subheading mx-3"
+            target="_blank"
+          >
+            {{ eco.text }}
+          </a>
+        </v-row>
+      </v-col>
+    </v-row>
+  </v-container>
 </template>
 
 <script>
-export default {
-  name: 'HelloWorld',
-  props: {
-    msg: String
+  export default {
+    name: 'HelloWorld',
+
+    data: () => ({
+      ecosystem: [
+        {
+          text: 'vuetify-loader',
+          href: 'https://github.com/vuetifyjs/vuetify-loader',
+        },
+        {
+          text: 'github',
+          href: 'https://github.com/vuetifyjs/vuetify',
+        },
+        {
+          text: 'awesome-vuetify',
+          href: 'https://github.com/vuetifyjs/awesome-vuetify',
+        },
+      ],
+      importantLinks: [
+        {
+          text: 'Documentation',
+          href: 'https://vuetifyjs.com',
+        },
+        {
+          text: 'Chat',
+          href: 'https://community.vuetifyjs.com',
+        },
+        {
+          text: 'Made with Vuetify',
+          href: 'https://madewithvuejs.com/vuetify',
+        },
+        {
+          text: 'Twitter',
+          href: 'https://twitter.com/vuetifyjs',
+        },
+        {
+          text: 'Articles',
+          href: 'https://medium.com/vuetify',
+        },
+      ],
+      whatsNext: [
+        {
+          text: 'Explore components',
+          href: 'https://vuetifyjs.com/components/api-explorer',
+        },
+        {
+          text: 'Select a layout',
+          href: 'https://vuetifyjs.com/layout/pre-defined',
+        },
+        {
+          text: 'Frequently Asked Questions',
+          href: 'https://vuetifyjs.com/getting-started/frequently-asked-questions',
+        },
+      ],
+    }),
   }
-}
 </script>
-
-<!-- Add "scoped" attribute to limit CSS to this component only -->
-<style scoped>
-h3 {
-  margin: 40px 0 0;
-}
-ul {
-  list-style-type: none;
-  padding: 0;
-}
-li {
-  display: inline-block;
-  margin: 0 10px;
-}
-a {
-  color: #42b983;
-}
-</style>
diff --git a/src/lib/RemoteFeed.vue b/src/lib/RemoteFeed.vue
new file mode 100644
index 0000000..338cffd
--- /dev/null
+++ b/src/lib/RemoteFeed.vue
@@ -0,0 +1,124 @@
+<template>
+    <div class="vid_main">
+        <video ref="feed_video" width="100%" height="100%" autoplay playsinline/>
+        <div class="info">{{ bitrate }}</div>
+        <div class="actions"></div>
+    </div>
+
+</template>
+
+<script>
+    export default {
+        props: {
+          janusInit: Object,
+          opaqueId: String,
+          room: Number,
+          mypvtid: String,
+          feedid: String
+        },
+        name: "RemoteFeed",
+        data: () => ({
+            remoteFeed: null,
+            bitrateTimer: null,
+            bitrate: 0
+        }),
+        mounted () {
+            console.log(this.janusInit)
+            this.janusInit.attach({
+                plugin: "janus.plugin.videoroom",
+                opaqueId: this.opaqueId,
+                success: this.onSuccess,
+                onmessage: this.onMessage,
+                    error: function(error) {
+                    console.log("  -- Error attaching plugin...", error);
+                    // bootbox.alert("Error attaching plugin... " + error);
+                },
+                webrtcState: function(on) {
+                    console.log("Janus says this WebRTC PeerConnection  " + (on ? "up" : "down") + " now");
+                },
+                onlocalstream: this.onlocalstream,
+                onremotestream: this.onStream
+
+            })
+        },
+        methods: {
+            onSuccess (pluginHandle) {
+                this.remoteFeed = pluginHandle;
+                this.remoteFeed.simulcastStarted = false;
+                console.log('Remote feed success')
+                var subscribe = { "request": "join", "room": this.room, "ptype": "subscriber", "feed": this.feedid, "private_id": this.mypvtid };
+
+                this.remoteFeed.send({"message": subscribe});
+
+            },
+            onlocalstream (locals) {
+                console.log(locals)
+            },
+            onStream (stream) {
+                console.log('stream is strarted')
+
+                this.$refs.feed_video.srcObject = stream
+                setInterval(() => {
+                    this.bitrate = this.remoteFeed.getBitrate()
+                },1000)
+            },
+            feedResponse (jsep) {
+                var body = { "request": "start", "room": this.room }
+                this.remoteFeed.send({"message": body, "jsep": jsep})
+            },
+            feedError (error) {
+                console.log("WebRTC error:", error)
+            },
+            onMessage (msg, jsep) {
+                console.log(msg)
+                console.log(jsep)
+                console.log("-------------------------")
+                var event = msg["videoroom"];
+                if(msg["error"] !== undefined && msg["error"] !== null) {
+                    console.log(msg["error"]);
+                } else if(event !== undefined && event != null) {
+                    this.remoteFeed.rfid = msg["id"]
+                    this.remoteFeed.rfdisplay = msg["display"]
+
+                } else if(event === "event") {
+                    var substream = msg["substream"]
+                    var temporal = msg["temporal"]
+                    console.log(substream,temporal)
+                }
+                if(jsep !== undefined && jsep !== null) {
+                    console.log('jsep')
+                    console.log(jsep)
+                    this.remoteFeed.createAnswer(
+                        {
+                            jsep: jsep,
+                            // Add data:true here if you want to subscribe to datachannels as well
+                            // (obviously only works if the publisher offered them in the first place)
+                            media: { audioSend: false, videoSend: false },	// We want recvonly audio/video
+                            success: this.feedResponse,
+                            error: this.feedError
+                        });
+                    }
+                },
+            onError (error) {
+                console.log(error)
+            }
+        }
+
+    }
+</script>
+
+<style scoped>
+    .actions {
+        position: absolute;
+        bottom:0;
+        left:0;
+    }
+    .vid_main {
+        position: relative;
+    }
+    .info {
+        position: absolute;
+        right: 0;
+        top:0;
+    }
+</style>
diff --git a/src/lib/VueJanus.vue b/src/lib/VueJanus.vue
new file mode 100644
index 0000000..4e3f3b5
--- /dev/null
+++ b/src/lib/VueJanus.vue
@@ -0,0 +1,279 @@
+<template>
+    <v-container>
+        <v-dialog
+                v-model="deviceSelectDialog"
+                max-width="290"
+        >
+            <v-card>
+                <v-card-title class="headline">Configuration</v-card-title>
+
+                <v-card-text>
+                    <v-row>
+                        <v-col md="12" cols="12">
+                            <v-select
+                                    label="Please select video device"
+                                    v-model="selectedVideo"
+                                    :items="videoDevices"
+                                    item-value="deviceId"
+                                    item-text="label"
+                            ></v-select>
+                        </v-col>
+                        <v-col md="12" cols="12">
+                            <v-select
+                                    label="Please select audio device"
+                                    :items="audioDevices"
+                                    v-model="selectedAudio"
+                                    item-value="deviceId"
+                                    item-text="label"
+                            ></v-select>
+                        </v-col>
+                    </v-row>
+                </v-card-text>
+
+                <v-card-actions>
+                    <v-spacer></v-spacer>
+
+                    <v-btn
+                            color="green darken-1"
+                            text
+                            @click="deviceSelectDialog = false"
+                    >
+                        Disagree
+                    </v-btn>
+
+                    <v-btn
+                            color="green darken-1"
+                            text
+                            @click="selectDevice"
+                    >
+                        Agree
+                    </v-btn>
+                </v-card-actions>
+            </v-card>
+        </v-dialog>
+        <v-btn @click="genRemoteFeed">Remote Feed</v-btn>
+        <v-row>
+            <v-col cols="12" md="3">
+                    <video ref="ownstream" class="rounded centered" id="myvideo" width="100%" height="100%" autoplay
+                           playsinline muted="muted"/>
+            </v-col>
+            <v-col cols="12" md="3" v-for="remoteStream in remoteStreams" :key="remoteStream.id">
+                    <RemoteFeed :opaqueId="opaqueId" :mypvtid="mypvtid" :feedid="remoteStream.id" :janusInit="janusInit" :room="room" ></RemoteFeed>
+            </v-col>
+        </v-row>
+    </v-container>
+</template>
+
+<script>
+
+
+    import RemoteFeed from "@/lib/RemoteFeed";
+    export default {
+        components: {RemoteFeed},
+        props: {
+            server: String,
+            room: Number,
+            username: String
+        },
+        data() {
+            return {
+                janusInit: null,
+                opaqueId: null,
+                pluginHandle: null,
+                mystream: null,
+                myid: '',
+                mypvtid: '',
+                selectedVideo: null,
+                selectedAudio: null,
+                videoDevices: [],
+                audioDevices: [],
+                deviceSelectDialog: false,
+                remoteStreams: []
+            }
+        },
+        name: "VueJanus",
+        mounted() {
+            this.janusInit = new this.$janus({
+                success: this.janusSuccess,
+                server: this.server,
+                error: function (error) {
+                    this.$janus.error(error);
+                },
+                destroyed: function () {
+                    window.location.reload();
+                }
+            })
+
+        },
+        methods: {
+            janusPluginError: function (error) {
+                console.log(error)
+            },
+            consentDialog: function (on) {
+                // this.$janus.debug("Consent dialog should be " + (on ? "on" : "off") + " now");
+                console.log(on)
+            },
+            janusPluginSuccess: function (pluginHandle) {
+                this.pluginHandle = pluginHandle
+                this.$janus.log("Plugin attached! (" + this.pluginHandle.getPlugin() + ", id=" + this.pluginHandle.getId() + ")");
+                this.$janus.log("  -- This is a publisher/manager");
+
+                this.$janus.listDevices(this.initDevices);
+
+
+            },
+            initDevices: function (devices) {
+                console.log(devices)
+                devices.forEach(device => {
+                    if (device.kind === 'videoinput') {
+                        this.videoDevices.push(device)
+                    }
+                    if (device.kind === 'audioinput') {
+                        this.audioDevices.push(device)
+                    }
+
+                })
+                this.deviceSelectDialog = true
+            },
+            genRemoteFeed: function () {
+                this.remoteStreams.forEach(item => {
+                    this.createRemoteFeed(item)
+                })
+            },
+            offerSend: function (jsep) {
+                console.log('vid offer')
+                var publish = {"request": "configure", "audio": true, "video": true};
+
+                this.pluginHandle.send({"message": publish, "jsep": jsep});
+            },
+            controlPublishers: function(msg) {
+                msg["publishers"].forEach(item => {
+                    var has = false
+                    this.remoteStreams.forEach(rm => {
+                        if (item.id === rm.id) has = true
+                    })
+                    if (!has) {
+                        this.remoteStreams.push(item)
+                    }
+
+                })
+            },
+            janusMessage: function (msg, jsep) {
+                // this.$janus.debug(" ::: Got a message (publisher) :::");
+                console.log(msg);
+                // this.$janus.debug(jsep);
+                var event = msg["videoroom"];
+                // this.$janus.debug("Event: " + event);
+                if (event !== undefined) {
+                    if (event === "joined") {
+                        this.myid = msg["id"];
+                        this.mypvtid = msg["private_id"];
+                        this.$janus.log("Successfully joined room " + msg["room"] + " with ID " + this.myid);
+                        this.restartDevices()
+                        if (msg["publishers"] !== undefined && msg["publishers"] !== null) {
+                            this.controlPublishers(msg)
+                        }
+                    } else if(event === "event") {
+                        // Any new feed to attach to?
+                        if (msg["publishers"] !== undefined && msg["publishers"] !== null) {
+                            this.controlPublishers(msg)
+
+                        } else if(msg["leaving"] !== undefined && msg["leaving"] !== null) {
+                            console.log("leaving")
+                            this.remoteStreams.forEach(item => {
+                                if (item.id === msg['leaving']) this.remoteStreams.splice(this.remoteStreams.indexOf(item),1)
+                            })
+                        }
+                    }
+                }
+                if (jsep !== undefined && jsep !== null) {
+
+                    console.log("Handling SDP as well...");
+                    console.log(jsep);
+                    this.pluginHandle.handleRemoteJsep({jsep: jsep});
+                    var audio = msg["audio_codec"];
+                    if (this.mystream && this.mystream.getAudioTracks() && this.mystream.getAudioTracks().length > 0 && !audio) {
+                        // Audio has been rejected
+                        //toastr.warning("Our audio stream has been rejected, viewers won't hear us");
+                        console.log("Our audio stream has been rejected, viewers won't hear us");
+                    }
+                }
+            },
+            onlocalstream: function (stream) {
+                // this.$janus.debug(" ::: Got a local stream :::");
+                // this.$janus.debug(stream);
+                this.mystream = stream
+                console.log(this.$refs)
+                console.log(this.$refs["ownstream"])
+                this.$refs.ownstream.srcObject = this.mystream
+
+            },
+            restartDevices: function () {
+                this.deviceSelectDialog = false
+
+                var media = {
+                    audioRecv: false, videoRecv: false, audioSend: true, videoSend: true,
+                    audio: {
+                        deviceId: {
+                            exact: this.selectedAudio
+                        }
+                    },
+                    replaceAudio: true,	// This is only needed in case of a renegotiation
+                    video: {
+                        deviceId: {
+                            exact: this.selectedVideo
+                        }
+                    },
+                    replaceVideo: true,
+                };
+
+
+                this.pluginHandle.createOffer(
+                    {
+                        media: media,
+                        success: this.offerSend,
+                        error: function (error) {
+                            // An error has occurred ...
+                            console.log(error)
+                        }
+                    })
+            },
+            webrtcState: function (on) {
+                this.$janus.log("Janus says our WebRTC PeerConnection is " + (on ? "up" : "down") + " now");
+            },
+            mediaState: function (medium, on) {
+                this.$janus.log("Janus " + (on ? "started" : "stopped") + " receiving our " + medium);
+            },
+            selectDevice: function () {
+                console.log(this.selectedVideo)
+                console.log(this.selectedAudio)
+                // this.$refs.ownstream.setSinkId(this.selectedVideo)
+                // this.$refs.ownstream.setSinkId(this.selectedAudio)
+
+                var register = {"request": "join", "room": this.room, "ptype": "publisher", "display": this.username};
+                this.pluginHandle.send({"message": register});
+            },
+            janusSuccess: function () {
+                this.opaqueId = "videoroomtest-" + this.$janus.randomString(12);
+
+                this.janusInit.attach(
+                    {
+                        plugin: "janus.plugin.videoroom",
+                        opaqueId: this.opaqueId,
+                        success: this.janusPluginSuccess,
+                        consentDialog: this.consentDialog,
+                        error: this.janusPluginError,
+                        mediaState: this.mediaState,
+                        webrtcState: this.webrtcState,
+                        onmessage: this.janusMessage,
+                        onlocalstream: this.onlocalstream
+                    }
+                )
+            }
+        }
+    }
+</script>
+
+<style scoped>
+
+</style>
diff --git a/src/lib/adapter.js b/src/lib/adapter.js
new file mode 100644
index 0000000..482572e
--- /dev/null
+++ b/src/lib/adapter.js
@@ -0,0 +1,2664 @@
+/* eslint-disable */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.adapter = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+        /* eslint-env node */
+        'use strict';
+
+// SDP helpers.
+        var SDPUtils = {};
+
+// Generate an alphanumeric identifier for cname or mids.
+// TODO: use Strings instead? https://gist.github.com/jed/982883
+        SDPUtils.generateIdentifier = function() {
+            return Math.random().toString(36).substr(2, 10);
+        };
+
+// The RTCP CNAME used by all peerconnections from the same JS.
+        SDPUtils.localCName = SDPUtils.generateIdentifier();
+
+// Splits SDP into lines, dealing with both CRLF and LF.
+        SDPUtils.splitLines = function(blob) {
+            return blob.trim().split('\n').map(function(line) {
+                return line.trim();
+            });
+        };
+// Splits SDP into sessionpart and mediasections. Ensures CRLF.
+        SDPUtils.splitSections = function(blob) {
+            var parts = blob.split('\nm=');
+            return parts.map(function(part, index) {
+                return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
+            });
+        };
+
+// Returns lines that start with a certain prefix.
+        SDPUtils.matchPrefix = function(blob, prefix) {
+            return SDPUtils.splitLines(blob).filter(function(line) {
+                return line.indexOf(prefix) === 0;
+            });
+        };
+
+// Parses an ICE candidate line. Sample input:
+// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
+// rport 55996"
+        SDPUtils.parseCandidate = function(line) {
+            var parts;
+            // Parse both variants.
+            if (line.indexOf('a=candidate:') === 0) {
+                parts = line.substring(12).split(' ');
+            } else {
+                parts = line.substring(10).split(' ');
+            }
+
+            var candidate = {
+                foundation: parts[0],
+                component: parts[1],
+                protocol: parts[2].toLowerCase(),
+                priority: parseInt(parts[3], 10),
+                ip: parts[4],
+                port: parseInt(parts[5], 10),
+                // skip parts[6] == 'typ'
+                type: parts[7]
+            };
+
+            for (var i = 8; i < parts.length; i += 2) {
+                switch (parts[i]) {
+                    case 'raddr':
+                        candidate.relatedAddress = parts[i + 1];
+                        break;
+                    case 'rport':
+                        candidate.relatedPort = parseInt(parts[i + 1], 10);
+                        break;
+                    case 'tcptype':
+                        candidate.tcpType = parts[i + 1];
+                        break;
+                    default: // Unknown extensions are silently ignored.
+                        break;
+                }
+            }
+            return candidate;
+        };
+
+// Translates a candidate object into SDP candidate attribute.
+        SDPUtils.writeCandidate = function(candidate) {
+            var sdp = [];
+            sdp.push(candidate.foundation);
+            sdp.push(candidate.component);
+            sdp.push(candidate.protocol.toUpperCase());
+            sdp.push(candidate.priority);
+            sdp.push(candidate.ip);
+            sdp.push(candidate.port);
+
+            var type = candidate.type;
+            sdp.push('typ');
+            sdp.push(type);
+            if (type !== 'host' && candidate.relatedAddress &&
+                candidate.relatedPort) {
+                sdp.push('raddr');
+                sdp.push(candidate.relatedAddress); // was: relAddr
+                sdp.push('rport');
+                sdp.push(candidate.relatedPort); // was: relPort
+            }
+            if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
+                sdp.push('tcptype');
+                sdp.push(candidate.tcpType);
+            }
+            return 'candidate:' + sdp.join(' ');
+        };
+
+// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
+// a=rtpmap:111 opus/48000/2
+        SDPUtils.parseRtpMap = function(line) {
+            var parts = line.substr(9).split(' ');
+            var parsed = {
+                payloadType: parseInt(parts.shift(), 10) // was: id
+            };
+
+            parts = parts[0].split('/');
+
+            parsed.name = parts[0];
+            parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
+            // was: channels
+            parsed.numChannels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+            return parsed;
+        };
+
+// Generate an a=rtpmap line from RTCRtpCodecCapability or
+// RTCRtpCodecParameters.
+        SDPUtils.writeRtpMap = function(codec) {
+            var pt = codec.payloadType;
+            if (codec.preferredPayloadType !== undefined) {
+                pt = codec.preferredPayloadType;
+            }
+            return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
+                (codec.numChannels !== 1 ? '/' + codec.numChannels : '') + '\r\n';
+        };
+
+// Parses an a=extmap line (headerextension from RFC 5285). Sample input:
+// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+        SDPUtils.parseExtmap = function(line) {
+            var parts = line.substr(9).split(' ');
+            return {
+                id: parseInt(parts[0], 10),
+                uri: parts[1]
+            };
+        };
+
+// Generates a=extmap line from RTCRtpHeaderExtensionParameters or
+// RTCRtpHeaderExtension.
+        SDPUtils.writeExtmap = function(headerExtension) {
+            return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
+                ' ' + headerExtension.uri + '\r\n';
+        };
+
+// Parses an ftmp line, returns dictionary. Sample input:
+// a=fmtp:96 vbr=on;cng=on
+// Also deals with vbr=on; cng=on
+        SDPUtils.parseFmtp = function(line) {
+            var parsed = {};
+            var kv;
+            var parts = line.substr(line.indexOf(' ') + 1).split(';');
+            for (var j = 0; j < parts.length; j++) {
+                kv = parts[j].trim().split('=');
+                parsed[kv[0].trim()] = kv[1];
+            }
+            return parsed;
+        };
+
+// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
+        SDPUtils.writeFmtp = function(codec) {
+            var line = '';
+            var pt = codec.payloadType;
+            if (codec.preferredPayloadType !== undefined) {
+                pt = codec.preferredPayloadType;
+            }
+            if (codec.parameters && Object.keys(codec.parameters).length) {
+                var params = [];
+                Object.keys(codec.parameters).forEach(function(param) {
+                    params.push(param + '=' + codec.parameters[param]);
+                });
+                line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
+            }
+            return line;
+        };
+
+// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
+// a=rtcp-fb:98 nack rpsi
+        SDPUtils.parseRtcpFb = function(line) {
+            var parts = line.substr(line.indexOf(' ') + 1).split(' ');
+            return {
+                type: parts.shift(),
+                parameter: parts.join(' ')
+            };
+        };
+// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
+        SDPUtils.writeRtcpFb = function(codec) {
+            var lines = '';
+            var pt = codec.payloadType;
+            if (codec.preferredPayloadType !== undefined) {
+                pt = codec.preferredPayloadType;
+            }
+            if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+                // FIXME: special handling for trr-int?
+                codec.rtcpFeedback.forEach(function(fb) {
+                    lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
+                        (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
+                        '\r\n';
+                });
+            }
+            return lines;
+        };
+
+// Parses an RFC 5576 ssrc media attribute. Sample input:
+// a=ssrc:3735928559 cname:something
+        SDPUtils.parseSsrcMedia = function(line) {
+            var sp = line.indexOf(' ');
+            var parts = {
+                ssrc: parseInt(line.substr(7, sp - 7), 10)
+            };
+            var colon = line.indexOf(':', sp);
+            if (colon > -1) {
+                parts.attribute = line.substr(sp + 1, colon - sp - 1);
+                parts.value = line.substr(colon + 1);
+            } else {
+                parts.attribute = line.substr(sp + 1);
+            }
+            return parts;
+        };
+
+// Extracts DTLS parameters from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the fingerprint line as input. See also getIceParameters.
+        SDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {
+            var lines = SDPUtils.splitLines(mediaSection);
+            // Search in session part, too.
+            lines = lines.concat(SDPUtils.splitLines(sessionpart));
+            var fpLine = lines.filter(function(line) {
+                return line.indexOf('a=fingerprint:') === 0;
+            })[0].substr(14);
+            // Note: a=setup line is ignored since we use the 'auto' role.
+            var dtlsParameters = {
+                role: 'auto',
+                fingerprints: [{
+                    algorithm: fpLine.split(' ')[0],
+                    value: fpLine.split(' ')[1]
+                }]
+            };
+            return dtlsParameters;
+        };
+
+// Serializes DTLS parameters to SDP.
+        SDPUtils.writeDtlsParameters = function(params, setupType) {
+            var sdp = 'a=setup:' + setupType + '\r\n';
+            params.fingerprints.forEach(function(fp) {
+                sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
+            });
+            return sdp;
+        };
+// Parses ICE information from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the ice-ufrag and ice-pwd lines as input.
+        SDPUtils.getIceParameters = function(mediaSection, sessionpart) {
+            var lines = SDPUtils.splitLines(mediaSection);
+            // Search in session part, too.
+            lines = lines.concat(SDPUtils.splitLines(sessionpart));
+            var iceParameters = {
+                usernameFragment: lines.filter(function(line) {
+                    return line.indexOf('a=ice-ufrag:') === 0;
+                })[0].substr(12),
+                password: lines.filter(function(line) {
+                    return line.indexOf('a=ice-pwd:') === 0;
+                })[0].substr(10)
+            };
+            return iceParameters;
+        };
+
+// Serializes ICE parameters to SDP.
+        SDPUtils.writeIceParameters = function(params) {
+            return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+                'a=ice-pwd:' + params.password + '\r\n';
+        };
+
+// Parses the SDP media section and returns RTCRtpParameters.
+        SDPUtils.parseRtpParameters = function(mediaSection) {
+            var description = {
+                codecs: [],
+                headerExtensions: [],
+                fecMechanisms: [],
+                rtcp: []
+            };
+            var lines = SDPUtils.splitLines(mediaSection);
+            var mline = lines[0].split(' ');
+            for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
+                var pt = mline[i];
+                var rtpmapline = SDPUtils.matchPrefix(
+                    mediaSection, 'a=rtpmap:' + pt + ' ')[0];
+                if (rtpmapline) {
+                    var codec = SDPUtils.parseRtpMap(rtpmapline);
+                    var fmtps = SDPUtils.matchPrefix(
+                        mediaSection, 'a=fmtp:' + pt + ' ');
+                    // Only the first a=fmtp:<pt> is considered.
+                    codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
+                    codec.rtcpFeedback = SDPUtils.matchPrefix(
+                        mediaSection, 'a=rtcp-fb:' + pt + ' ')
+                        .map(SDPUtils.parseRtcpFb);
+                    description.codecs.push(codec);
+                    // parse FEC mechanisms from rtpmap lines.
+                    switch (codec.name.toUpperCase()) {
+                        case 'RED':
+                        case 'ULPFEC':
+                            description.fecMechanisms.push(codec.name.toUpperCase());
+                            break;
+                        default: // only RED and ULPFEC are recognized as FEC mechanisms.
+                            break;
+                    }
+                }
+            }
+            SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {
+                description.headerExtensions.push(SDPUtils.parseExtmap(line));
+            });
+            // FIXME: parse rtcp.
+            return description;
+        };
+
+// Generates parts of the SDP media section describing the capabilities /
+// parameters.
+        SDPUtils.writeRtpDescription = function(kind, caps) {
+            var sdp = '';
+
+            // Build the mline.
+            sdp += 'm=' + kind + ' ';
+            sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
+            sdp += ' UDP/TLS/RTP/SAVPF ';
+            sdp += caps.codecs.map(function(codec) {
+                if (codec.preferredPayloadType !== undefined) {
+                    return codec.preferredPayloadType;
+                }
+                return codec.payloadType;
+            }).join(' ') + '\r\n';
+
+            sdp += 'c=IN IP4 0.0.0.0\r\n';
+            sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
+
+            // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
+            caps.codecs.forEach(function(codec) {
+                sdp += SDPUtils.writeRtpMap(codec);
+                sdp += SDPUtils.writeFmtp(codec);
+                sdp += SDPUtils.writeRtcpFb(codec);
+            });
+            // FIXME: add headerExtensions, fecMechanismş and rtcp.
+            sdp += 'a=rtcp-mux\r\n';
+            return sdp;
+        };
+
+// Parses the SDP media section and returns an array of
+// RTCRtpEncodingParameters.
+        SDPUtils.parseRtpEncodingParameters = function(mediaSection) {
+            var encodingParameters = [];
+            var description = SDPUtils.parseRtpParameters(mediaSection);
+            var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
+            var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
+
+            // filter a=ssrc:... cname:, ignore PlanB-msid
+            var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+                .map(function(line) {
+                    return SDPUtils.parseSsrcMedia(line);
+                })
+                .filter(function(parts) {
+                    return parts.attribute === 'cname';
+                });
+            var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+            var secondarySsrc;
+
+            var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
+                .map(function(line) {
+                    var parts = line.split(' ');
+                    parts.shift();
+                    return parts.map(function(part) {
+                        return parseInt(part, 10);
+                    });
+                });
+            if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+                secondarySsrc = flows[0][1];
+            }
+
+            description.codecs.forEach(function(codec) {
+                if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
+                    var encParam = {
+                        ssrc: primarySsrc,
+                        codecPayloadType: parseInt(codec.parameters.apt, 10),
+                        rtx: {
+                            payloadType: codec.payloadType,
+                            ssrc: secondarySsrc
+                        }
+                    };
+                    encodingParameters.push(encParam);
+                    if (hasRed) {
+                        encParam = JSON.parse(JSON.stringify(encParam));
+                        encParam.fec = {
+                            ssrc: secondarySsrc,
+                            mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
+                        };
+                        encodingParameters.push(encParam);
+                    }
+                }
+            });
+            if (encodingParameters.length === 0 && primarySsrc) {
+                encodingParameters.push({
+                    ssrc: primarySsrc
+                });
+            }
+
+            // we support both b=AS and b=TIAS but interpret AS as TIAS.
+            var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
+            if (bandwidth.length) {
+                if (bandwidth[0].indexOf('b=TIAS:') === 0) {
+                    bandwidth = parseInt(bandwidth[0].substr(7), 10);
+                } else if (bandwidth[0].indexOf('b=AS:') === 0) {
+                    bandwidth = parseInt(bandwidth[0].substr(5), 10);
+                }
+                encodingParameters.forEach(function(params) {
+                    params.maxBitrate = bandwidth;
+                });
+            }
+            return encodingParameters;
+        };
+
+        SDPUtils.writeSessionBoilerplate = function() {
+            // FIXME: sess-id should be an NTP timestamp.
+            return 'v=0\r\n' +
+                'o=thisisadapterortc 8169639915646943137 2 IN IP4 127.0.0.1\r\n' +
+                's=-\r\n' +
+                't=0 0\r\n';
+        };
+
+        SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
+            var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+            // Map ICE parameters (ufrag, pwd) to SDP.
+            sdp += SDPUtils.writeIceParameters(
+                transceiver.iceGatherer.getLocalParameters());
+
+            // Map DTLS parameters to SDP.
+            sdp += SDPUtils.writeDtlsParameters(
+                transceiver.dtlsTransport.getLocalParameters(),
+                type === 'offer' ? 'actpass' : 'active');
+
+            sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+            if (transceiver.rtpSender && transceiver.rtpReceiver) {
+                sdp += 'a=sendrecv\r\n';
+            } else if (transceiver.rtpSender) {
+                sdp += 'a=sendonly\r\n';
+            } else if (transceiver.rtpReceiver) {
+                sdp += 'a=recvonly\r\n';
+            } else {
+                sdp += 'a=inactive\r\n';
+            }
+
+            // FIXME: for RTX there might be multiple SSRCs. Not implemented in Edge yet.
+            if (transceiver.rtpSender) {
+                var msid = 'msid:' + stream.id + ' ' +
+                    transceiver.rtpSender.track.id + '\r\n';
+                sdp += 'a=' + msid;
+                sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+                    ' ' + msid;
+            }
+            // FIXME: this should be written by writeRtpDescription.
+            sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+                ' cname:' + SDPUtils.localCName + '\r\n';
+            return sdp;
+        };
+
+// Gets the direction from the mediaSection or the sessionpart.
+        SDPUtils.getDirection = function(mediaSection, sessionpart) {
+            // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
+            var lines = SDPUtils.splitLines(mediaSection);
+            for (var i = 0; i < lines.length; i++) {
+                switch (lines[i]) {
+                    case 'a=sendrecv':
+                    case 'a=sendonly':
+                    case 'a=recvonly':
+                    case 'a=inactive':
+                        return lines[i].substr(2);
+                    default:
+                    // FIXME: What should happen here?
+                }
+            }
+            if (sessionpart) {
+                return SDPUtils.getDirection(sessionpart);
+            }
+            return 'sendrecv';
+        };
+
+// Expose public methods.
+        module.exports = SDPUtils;
+
+    },{}],2:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+
+        'use strict';
+
+// Shimming starts here.
+        (function() {
+            // Utils.
+            var logging = require('./utils').log;
+            var browserDetails = require('./utils').browserDetails;
+            // Export to the adapter global object visible in the browser.
+            module.exports.browserDetails = browserDetails;
+            module.exports.extractVersion = require('./utils').extractVersion;
+            module.exports.disableLog = require('./utils').disableLog;
+
+            // Uncomment the line below if you want logging to occur, including logging
+            // for the switch statement below. Can also be turned on in the browser via
+            // adapter.disableLog(false), but then logging from the switch statement below
+            // will not appear.
+            // require('./utils').disableLog(false);
+
+            // Browser shims.
+            var chromeShim = require('./chrome/chrome_shim') || null;
+            var edgeShim = require('./edge/edge_shim') || null;
+            var firefoxShim = require('./firefox/firefox_shim') || null;
+            var safariShim = require('./safari/safari_shim') || null;
+
+            // Shim browser if found.
+            switch (browserDetails.browser) {
+                case 'opera': // fallthrough as it uses chrome shims
+                case 'chrome':
+                    if (!chromeShim || !chromeShim.shimPeerConnection) {
+                        logging('Chrome shim is not included in this adapter release.');
+                        return;
+                    }
+                    logging('adapter.js shimming chrome.');
+                    // Export to the adapter global object visible in the browser.
+                    module.exports.browserShim = chromeShim;
+
+                    chromeShim.shimGetUserMedia();
+                    chromeShim.shimMediaStream();
+                    chromeShim.shimSourceObject();
+                    chromeShim.shimPeerConnection();
+                    chromeShim.shimOnTrack();
+                    break;
+                case 'firefox':
+                    if (!firefoxShim || !firefoxShim.shimPeerConnection) {
+                        logging('Firefox shim is not included in this adapter release.');
+                        return;
+                    }
+                    logging('adapter.js shimming firefox.');
+                    // Export to the adapter global object visible in the browser.
+                    module.exports.browserShim = firefoxShim;
+
+                    firefoxShim.shimGetUserMedia();
+                    firefoxShim.shimSourceObject();
+                    firefoxShim.shimPeerConnection();
+                    firefoxShim.shimOnTrack();
+                    break;
+                case 'edge':
+                    if (!edgeShim || !edgeShim.shimPeerConnection) {
+                        logging('MS edge shim is not included in this adapter release.');
+                        return;
+                    }
+                    logging('adapter.js shimming edge.');
+                    // Export to the adapter global object visible in the browser.
+                    module.exports.browserShim = edgeShim;
+
+                    edgeShim.shimGetUserMedia();
+                    edgeShim.shimPeerConnection();
+                    break;
+                case 'safari':
+                    if (!safariShim) {
+                        logging('Safari shim is not included in this adapter release.');
+                        return;
+                    }
+                    logging('adapter.js shimming safari.');
+                    // Export to the adapter global object visible in the browser.
+                    module.exports.browserShim = safariShim;
+
+                    safariShim.shimGetUserMedia();
+                    break;
+                default:
+                    logging('Unsupported browser!');
+            }
+        })();
+
+    },{"./chrome/chrome_shim":3,"./edge/edge_shim":5,"./firefox/firefox_shim":7,"./safari/safari_shim":9,"./utils":10}],3:[function(require,module,exports){
+
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+        var logging = require('../utils.js').log;
+        var browserDetails = require('../utils.js').browserDetails;
+
+        var chromeShim = {
+            shimMediaStream: function() {
+                window.MediaStream = window.MediaStream || window.webkitMediaStream;
+            },
+
+            shimOnTrack: function() {
+                if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
+                    window.RTCPeerConnection.prototype)) {
+                    Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
+                        get: function() {
+                            return this._ontrack;
+                        },
+                        set: function(f) {
+                            var self = this;
+                            if (this._ontrack) {
+                                this.removeEventListener('track', this._ontrack);
+                                this.removeEventListener('addstream', this._ontrackpoly);
+                            }
+                            this.addEventListener('track', this._ontrack = f);
+                            this.addEventListener('addstream', this._ontrackpoly = function(e) {
+                                // onaddstream does not fire when a track is added to an existing
+                                // stream. But stream.onaddtrack is implemented so we use that.
+                                e.stream.addEventListener('addtrack', function(te) {
+                                    var event = new Event('track');
+                                    event.track = te.track;
+                                    event.receiver = {track: te.track};
+                                    event.streams = [e.stream];
+                                    self.dispatchEvent(event);
+                                });
+                                e.stream.getTracks().forEach(function(track) {
+                                    var event = new Event('track');
+                                    event.track = track;
+                                    event.receiver = {track: track};
+                                    event.streams = [e.stream];
+                                    this.dispatchEvent(event);
+                                }.bind(this));
+                            }.bind(this));
+                        }
+                    });
+                }
+            },
+
+            shimSourceObject: function() {
+                if (typeof window === 'object') {
+                    if (window.HTMLMediaElement &&
+                        !('srcObject' in window.HTMLMediaElement.prototype)) {
+                        // Shim the srcObject property, once, when HTMLMediaElement is found.
+                        Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
+                            get: function() {
+                                return this._srcObject;
+                            },
+                            set: function(stream) {
+                                var self = this;
+                                // Use _srcObject as a private property for this shim
+                                this._srcObject = stream;
+                                if (this.src) {
+                                    URL.revokeObjectURL(this.src);
+                                }
+
+                                if (!stream) {
+                                    this.src = '';
+                                    return;
+                                }
+                                this.src = URL.createObjectURL(stream);
+                                // We need to recreate the blob url when a track is added or
+                                // removed. Doing it manually since we want to avoid a recursion.
+                                stream.addEventListener('addtrack', function() {
+                                    if (self.src) {
+                                        URL.revokeObjectURL(self.src);
+                                    }
+                                    self.src = URL.createObjectURL(stream);
+                                });
+                                stream.addEventListener('removetrack', function() {
+                                    if (self.src) {
+                                        URL.revokeObjectURL(self.src);
+                                    }
+                                    self.src = URL.createObjectURL(stream);
+                                });
+                            }
+                        });
+                    }
+                }
+            },
+
+            shimPeerConnection: function() {
+                // The RTCPeerConnection object.
+                window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+                    // Translate iceTransportPolicy to iceTransports,
+                    // see https://code.google.com/p/webrtc/issues/detail?id=4869
+                    logging('PeerConnection');
+                    if (pcConfig && pcConfig.iceTransportPolicy) {
+                        pcConfig.iceTransports = pcConfig.iceTransportPolicy;
+                    }
+
+                    var pc = new webkitRTCPeerConnection(pcConfig, pcConstraints);
+                    var origGetStats = pc.getStats.bind(pc);
+                    pc.getStats = function(selector, successCallback, errorCallback) {
+                        var self = this;
+                        var args = arguments;
+
+                        // If selector is a function then we are in the old style stats so just
+                        // pass back the original getStats format to avoid breaking old users.
+                        if (arguments.length > 0 && typeof selector === 'function') {
+                            return origGetStats(selector, successCallback);
+                        }
+
+                        var fixChromeStats_ = function(response) {
+                            var standardReport = {};
+                            var reports = response.result();
+                            reports.forEach(function(report) {
+                                var standardStats = {
+                                    id: report.id,
+                                    timestamp: report.timestamp,
+                                    type: report.type
+                                };
+                                report.names().forEach(function(name) {
+                                    standardStats[name] = report.stat(name);
+                                });
+                                standardReport[standardStats.id] = standardStats;
+                            });
+
+                            return standardReport;
+                        };
+
+                        // shim getStats with maplike support
+                        var makeMapStats = function(stats, legacyStats) {
+                            var map = new Map(Object.keys(stats).map(function(key) {
+                                return[key, stats[key]];
+                            }));
+                            legacyStats = legacyStats || stats;
+                            Object.keys(legacyStats).forEach(function(key) {
+                                map[key] = legacyStats[key];
+                            });
+                            return map;
+                        };
+
+                        if (arguments.length >= 2) {
+                            var successCallbackWrapper_ = function(response) {
+                                args[1](makeMapStats(fixChromeStats_(response)));
+                            };
+
+                            return origGetStats.apply(this, [successCallbackWrapper_,
+                                arguments[0]]);
+                        }
+
+                        // promise-support
+                        return new Promise(function(resolve, reject) {
+                            if (args.length === 1 && typeof selector === 'object') {
+                                origGetStats.apply(self, [
+                                    function(response) {
+                                        resolve(makeMapStats(fixChromeStats_(response)));
+                                    }, reject]);
+                            } else {
+                                // Preserve legacy chrome stats only on legacy access of stats obj
+                                origGetStats.apply(self, [
+                                    function(response) {
+                                        resolve(makeMapStats(fixChromeStats_(response),
+                                            response.result()));
+                                    }, reject]);
+                            }
+                        }).then(successCallback, errorCallback);
+                    };
+
+                    return pc;
+                };
+                window.RTCPeerConnection.prototype = webkitRTCPeerConnection.prototype;
+
+                // wrap static methods. Currently just generateCertificate.
+                if (webkitRTCPeerConnection.generateCertificate) {
+                    Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                        get: function() {
+                            return webkitRTCPeerConnection.generateCertificate;
+                        }
+                    });
+                }
+
+                ['createOffer', 'createAnswer'].forEach(function(method) {
+                    var nativeMethod = webkitRTCPeerConnection.prototype[method];
+                    webkitRTCPeerConnection.prototype[method] = function() {
+                        var self = this;
+                        if (arguments.length < 1 || (arguments.length === 1 &&
+                            typeof arguments[0] === 'object')) {
+                            var opts = arguments.length === 1 ? arguments[0] : undefined;
+                            return new Promise(function(resolve, reject) {
+                                nativeMethod.apply(self, [resolve, reject, opts]);
+                            });
+                        }
+                        return nativeMethod.apply(this, arguments);
+                    };
+                });
+
+                // add promise support -- natively available in Chrome 51
+                if (browserDetails.version < 51) {
+                    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+                        .forEach(function(method) {
+                            var nativeMethod = webkitRTCPeerConnection.prototype[method];
+                            webkitRTCPeerConnection.prototype[method] = function() {
+                                var args = arguments;
+                                var self = this;
+                                var promise = new Promise(function(resolve, reject) {
+                                    nativeMethod.apply(self, [args[0], resolve, reject]);
+                                });
+                                if (args.length < 2) {
+                                    return promise;
+                                }
+                                return promise.then(function() {
+                                        args[1].apply(null, []);
+                                    },
+                                    function(err) {
+                                        if (args.length >= 3) {
+                                            args[2].apply(null, [err]);
+                                        }
+                                    });
+                            };
+                        });
+                }
+
+                // shim implicit creation of RTCSessionDescription/RTCIceCandidate
+                ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+                    .forEach(function(method) {
+                        var nativeMethod = webkitRTCPeerConnection.prototype[method];
+                        webkitRTCPeerConnection.prototype[method] = function() {
+                            arguments[0] = new ((method === 'addIceCandidate') ?
+                                RTCIceCandidate : RTCSessionDescription)(arguments[0]);
+                            return nativeMethod.apply(this, arguments);
+                        };
+                    });
+
+                // support for addIceCandidate(null)
+                var nativeAddIceCandidate =
+                    RTCPeerConnection.prototype.addIceCandidate;
+                RTCPeerConnection.prototype.addIceCandidate = function() {
+                    return arguments[0] === null ? Promise.resolve()
+                        : nativeAddIceCandidate.apply(this, arguments);
+                };
+            }
+        };
+
+
+// Expose public methods.
+        module.exports = {
+            shimMediaStream: chromeShim.shimMediaStream,
+            shimOnTrack: chromeShim.shimOnTrack,
+            shimSourceObject: chromeShim.shimSourceObject,
+            shimPeerConnection: chromeShim.shimPeerConnection,
+            shimGetUserMedia: require('./getusermedia')
+        };
+
+    },{"../utils.js":10,"./getusermedia":4}],4:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+        var logging = require('../utils.js').log;
+
+// Expose public methods.
+        module.exports = function() {
+            var constraintsToChrome_ = function(c) {
+                if (typeof c !== 'object' || c.mandatory || c.optional) {
+                    return c;
+                }
+                var cc = {};
+                Object.keys(c).forEach(function(key) {
+                    if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
+                        return;
+                    }
+                    var r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};
+                    if (r.exact !== undefined && typeof r.exact === 'number') {
+                        r.min = r.max = r.exact;
+                    }
+                    var oldname_ = function(prefix, name) {
+                        if (prefix) {
+                            return prefix + name.charAt(0).toUpperCase() + name.slice(1);
+                        }
+                        return (name === 'deviceId') ? 'sourceId' : name;
+                    };
+                    if (r.ideal !== undefined) {
+                        cc.optional = cc.optional || [];
+                        var oc = {};
+                        if (typeof r.ideal === 'number') {
+                            oc[oldname_('min', key)] = r.ideal;
+                            cc.optional.push(oc);
+                            oc = {};
+                            oc[oldname_('max', key)] = r.ideal;
+                            cc.optional.push(oc);
+                        } else {
+                            oc[oldname_('', key)] = r.ideal;
+                            cc.optional.push(oc);
+                        }
+                    }
+                    if (r.exact !== undefined && typeof r.exact !== 'number') {
+                        cc.mandatory = cc.mandatory || {};
+                        cc.mandatory[oldname_('', key)] = r.exact;
+                    } else {
+                        ['min', 'max'].forEach(function(mix) {
+                            if (r[mix] !== undefined) {
+                                cc.mandatory = cc.mandatory || {};
+                                cc.mandatory[oldname_(mix, key)] = r[mix];
+                            }
+                        });
+                    }
+                });
+                if (c.advanced) {
+                    cc.optional = (cc.optional || []).concat(c.advanced);
+                }
+                return cc;
+            };
+
+            var shimConstraints_ = function(constraints, func) {
+                constraints = JSON.parse(JSON.stringify(constraints));
+                if (constraints && constraints.audio) {
+                    constraints.audio = constraintsToChrome_(constraints.audio);
+                }
+                if (constraints && typeof constraints.video === 'object') {
+                    // Shim facingMode for mobile, where it defaults to "user".
+                    var face = constraints.video.facingMode;
+                    face = face && ((typeof face === 'object') ? face : {ideal: face});
+
+                    if ((face && (face.exact === 'user' || face.exact === 'environment' ||
+                        face.ideal === 'user' || face.ideal === 'environment')) &&
+                        !(navigator.mediaDevices.getSupportedConstraints &&
+                            navigator.mediaDevices.getSupportedConstraints().facingMode)) {
+                        delete constraints.video.facingMode;
+                        if (face.exact === 'environment' || face.ideal === 'environment') {
+                            // Look for "back" in label, or use last cam (typically back cam).
+                            return navigator.mediaDevices.enumerateDevices()
+                                .then(function(devices) {
+                                    devices = devices.filter(function(d) {
+                                        return d.kind === 'videoinput';
+                                    });
+                                    var back = devices.find(function(d) {
+                                        return d.label.toLowerCase().indexOf('back') !== -1;
+                                    }) || (devices.length && devices[devices.length - 1]);
+                                    if (back) {
+                                        constraints.video.deviceId = face.exact ? {exact: back.deviceId} :
+                                            {ideal: back.deviceId};
+                                    }
+                                    constraints.video = constraintsToChrome_(constraints.video);
+                                    logging('chrome: ' + JSON.stringify(constraints));
+                                    return func(constraints);
+                                });
+                        }
+                    }
+                    constraints.video = constraintsToChrome_(constraints.video);
+                }
+                logging('chrome: ' + JSON.stringify(constraints));
+                return func(constraints);
+            };
+
+            var shimError_ = function(e) {
+                return {
+                    name: {
+                        PermissionDeniedError: 'NotAllowedError',
+                        ConstraintNotSatisfiedError: 'OverconstrainedError'
+                    }[e.name] || e.name,
+                    message: e.message,
+                    constraint: e.constraintName,
+                    toString: function() {
+                        return this.name + (this.message && ': ') + this.message;
+                    }
+                };
+            };
+
+            var getUserMedia_ = function(constraints, onSuccess, onError) {
+                shimConstraints_(constraints, function(c) {
+                    navigator.webkitGetUserMedia(c, onSuccess, function(e) {
+                        onError(shimError_(e));
+                    });
+                });
+            };
+
+            navigator.getUserMedia = getUserMedia_;
+
+            // Returns the result of getUserMedia as a Promise.
+            var getUserMediaPromise_ = function(constraints) {
+                return new Promise(function(resolve, reject) {
+                    navigator.getUserMedia(constraints, resolve, reject);
+                });
+            };
+
+            if (!navigator.mediaDevices) {
+                navigator.mediaDevices = {
+                    getUserMedia: getUserMediaPromise_,
+                    enumerateDevices: function() {
+                        return new Promise(function(resolve) {
+                            var kinds = {audio: 'audioinput', video: 'videoinput'};
+                            return MediaStreamTrack.getSources(function(devices) {
+                                resolve(devices.map(function(device) {
+                                    return {label: device.label,
+                                        kind: kinds[device.kind],
+                                        deviceId: device.id,
+                                        groupId: ''};
+                                }));
+                            });
+                        });
+                    }
+                };
+            }
+
+            // A shim for getUserMedia method on the mediaDevices object.
+            // TODO(KaptenJansson) remove once implemented in Chrome stable.
+            if (!navigator.mediaDevices.getUserMedia) {
+                navigator.mediaDevices.getUserMedia = function(constraints) {
+                    return getUserMediaPromise_(constraints);
+                };
+            } else {
+                // Even though Chrome 45 has navigator.mediaDevices and a getUserMedia
+                // function which returns a Promise, it does not accept spec-style
+                // constraints.
+                var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+                bind(navigator.mediaDevices);
+                navigator.mediaDevices.getUserMedia = function(cs) {
+                    return shimConstraints_(cs, function(c) {
+                        return origGetUserMedia(c).then(function(stream) {
+                            if (c.audio && !stream.getAudioTracks().length ||
+                                c.video && !stream.getVideoTracks().length) {
+                                stream.getTracks().forEach(function(track) {
+                                    track.stop();
+                                });
+                                throw new DOMException('', 'NotFoundError');
+                            }
+                            return stream;
+                        }, function(e) {
+                            return Promise.reject(shimError_(e));
+                        });
+                    });
+                };
+            }
+
+            // Dummy devicechange event methods.
+            // TODO(KaptenJansson) remove once implemented in Chrome stable.
+            if (typeof navigator.mediaDevices.addEventListener === 'undefined') {
+                navigator.mediaDevices.addEventListener = function() {
+                    logging('Dummy mediaDevices.addEventListener called.');
+                };
+            }
+            if (typeof navigator.mediaDevices.removeEventListener === 'undefined') {
+                navigator.mediaDevices.removeEventListener = function() {
+                    logging('Dummy mediaDevices.removeEventListener called.');
+                };
+            }
+        };
+
+    },{"../utils.js":10}],5:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+
+        var SDPUtils = require('sdp');
+        var browserDetails = require('../utils').browserDetails;
+
+        var edgeShim = {
+            shimPeerConnection: function() {
+                if (window.RTCIceGatherer) {
+                    // ORTC defines an RTCIceCandidate object but no constructor.
+                    // Not implemented in Edge.
+                    if (!window.RTCIceCandidate) {
+                        window.RTCIceCandidate = function(args) {
+                            return args;
+                        };
+                    }
+                    // ORTC does not have a session description object but
+                    // other browsers (i.e. Chrome) that will support both PC and ORTC
+                    // in the future might have this defined already.
+                    if (!window.RTCSessionDescription) {
+                        window.RTCSessionDescription = function(args) {
+                            return args;
+                        };
+                    }
+                }
+
+                window.RTCPeerConnection = function(config) {
+                    var self = this;
+
+                    var _eventTarget = document.createDocumentFragment();
+                    ['addEventListener', 'removeEventListener', 'dispatchEvent']
+                        .forEach(function(method) {
+                            self[method] = _eventTarget[method].bind(_eventTarget);
+                        });
+
+                    this.onicecandidate = null;
+                    this.onaddstream = null;
+                    this.ontrack = null;
+                    this.onremovestream = null;
+                    this.onsignalingstatechange = null;
+                    this.oniceconnectionstatechange = null;
+                    this.onnegotiationneeded = null;
+                    this.ondatachannel = null;
+
+                    this.localStreams = [];
+                    this.remoteStreams = [];
+                    this.getLocalStreams = function() {
+                        return self.localStreams;
+                    };
+                    this.getRemoteStreams = function() {
+                        return self.remoteStreams;
+                    };
+
+                    this.localDescription = new RTCSessionDescription({
+                        type: '',
+                        sdp: ''
+                    });
+                    this.remoteDescription = new RTCSessionDescription({
+                        type: '',
+                        sdp: ''
+                    });
+                    this.signalingState = 'stable';
+                    this.iceConnectionState = 'new';
+                    this.iceGatheringState = 'new';
+
+                    this.iceOptions = {
+                        gatherPolicy: 'all',
+                        iceServers: []
+                    };
+                    if (config && config.iceTransportPolicy) {
+                        switch (config.iceTransportPolicy) {
+                            case 'all':
+                            case 'relay':
+                                this.iceOptions.gatherPolicy = config.iceTransportPolicy;
+                                break;
+                            case 'none':
+                                // FIXME: remove once implementation and spec have added this.
+                                throw new TypeError('iceTransportPolicy "none" not supported');
+                            default:
+                                // don't set iceTransportPolicy.
+                                break;
+                        }
+                    }
+                    this.usingBundle = config && config.bundlePolicy === 'max-bundle';
+
+                    if (config && config.iceServers) {
+                        // Edge does not like
+                        // 1) stun:
+                        // 2) turn: that does not have all of turn:host:port?transport=udp
+                        // 3) turn: with ipv6 addresses
+                        var iceServers = JSON.parse(JSON.stringify(config.iceServers));
+                        this.iceOptions.iceServers = iceServers.filter(function(server) {
+                            if (server && server.urls) {
+                                var urls = server.urls;
+                                if (typeof urls === 'string') {
+                                    urls = [urls];
+                                }
+                                urls = urls.filter(function(url) {
+                                    return (url.indexOf('turn:') === 0 &&
+                                        url.indexOf('transport=udp') !== -1 &&
+                                        url.indexOf('turn:[') === -1) ||
+                                        (url.indexOf('stun:') === 0 &&
+                                            browserDetails.version >= 14393);
+                                })[0];
+                                return !!urls;
+                            }
+                            return false;
+                        });
+                    }
+
+                    // per-track iceGathers, iceTransports, dtlsTransports, rtpSenders, ...
+                    // everything that is needed to describe a SDP m-line.
+                    this.transceivers = [];
+
+                    // since the iceGatherer is currently created in createOffer but we
+                    // must not emit candidates until after setLocalDescription we buffer
+                    // them in this array.
+                    this._localIceCandidatesBuffer = [];
+                };
+
+                window.RTCPeerConnection.prototype._emitBufferedCandidates = function() {
+                    var self = this;
+                    var sections = SDPUtils.splitSections(self.localDescription.sdp);
+                    // FIXME: need to apply ice candidates in a way which is async but
+                    // in-order
+                    this._localIceCandidatesBuffer.forEach(function(event) {
+                        var end = !event.candidate || Object.keys(event.candidate).length === 0;
+                        if (end) {
+                            for (var j = 1; j < sections.length; j++) {
+                                if (sections[j].indexOf('\r\na=end-of-candidates\r\n') === -1) {
+                                    sections[j] += 'a=end-of-candidates\r\n';
+                                }
+                            }
+                        } else if (event.candidate.candidate.indexOf('typ endOfCandidates')
+                            === -1) {
+                            sections[event.candidate.sdpMLineIndex + 1] +=
+                                'a=' + event.candidate.candidate + '\r\n';
+                        }
+                        self.localDescription.sdp = sections.join('');
+                        self.dispatchEvent(event);
+                        if (self.onicecandidate !== null) {
+                            self.onicecandidate(event);
+                        }
+                        if (!event.candidate && self.iceGatheringState !== 'complete') {
+                            var complete = self.transceivers.every(function(transceiver) {
+                                return transceiver.iceGatherer &&
+                                    transceiver.iceGatherer.state === 'completed';
+                            });
+                            if (complete) {
+                                self.iceGatheringState = 'complete';
+                            }
+                        }
+                    });
+                    this._localIceCandidatesBuffer = [];
+                };
+
+                window.RTCPeerConnection.prototype.addStream = function(stream) {
+                    // Clone is necessary for local demos mostly, attaching directly
+                    // to two different senders does not work (build 10547).
+                    this.localStreams.push(stream.clone());
+                    this._maybeFireNegotiationNeeded();
+                };
+
+                window.RTCPeerConnection.prototype.removeStream = function(stream) {
+                    var idx = this.localStreams.indexOf(stream);
+                    if (idx > -1) {
+                        this.localStreams.splice(idx, 1);
+                        this._maybeFireNegotiationNeeded();
+                    }
+                };
+
+                window.RTCPeerConnection.prototype.getSenders = function() {
+                    return this.transceivers.filter(function(transceiver) {
+                        return !!transceiver.rtpSender;
+                    })
+                        .map(function(transceiver) {
+                            return transceiver.rtpSender;
+                        });
+                };
+
+                window.RTCPeerConnection.prototype.getReceivers = function() {
+                    return this.transceivers.filter(function(transceiver) {
+                        return !!transceiver.rtpReceiver;
+                    })
+                        .map(function(transceiver) {
+                            return transceiver.rtpReceiver;
+                        });
+                };
+
+                // Determines the intersection of local and remote capabilities.
+                window.RTCPeerConnection.prototype._getCommonCapabilities =
+                    function(localCapabilities, remoteCapabilities) {
+                        var commonCapabilities = {
+                            codecs: [],
+                            headerExtensions: [],
+                            fecMechanisms: []
+                        };
+                        localCapabilities.codecs.forEach(function(lCodec) {
+                            for (var i = 0; i < remoteCapabilities.codecs.length; i++) {
+                                var rCodec = remoteCapabilities.codecs[i];
+                                if (lCodec.name.toLowerCase() === rCodec.name.toLowerCase() &&
+                                    lCodec.clockRate === rCodec.clockRate &&
+                                    lCodec.numChannels === rCodec.numChannels) {
+                                    // push rCodec so we reply with offerer payload type
+                                    commonCapabilities.codecs.push(rCodec);
+
+                                    // determine common feedback mechanisms
+                                    rCodec.rtcpFeedback = rCodec.rtcpFeedback.filter(function(fb) {
+                                        for (var j = 0; j < lCodec.rtcpFeedback.length; j++) {
+                                            if (lCodec.rtcpFeedback[j].type === fb.type &&
+                                                lCodec.rtcpFeedback[j].parameter === fb.parameter) {
+                                                return true;
+                                            }
+                                        }
+                                        return false;
+                                    });
+                                    // FIXME: also need to determine .parameters
+                                    //  see https://github.com/openpeer/ortc/issues/569
+                                    break;
+                                }
+                            }
+                        });
+
+                        localCapabilities.headerExtensions
+                            .forEach(function(lHeaderExtension) {
+                                for (var i = 0; i < remoteCapabilities.headerExtensions.length;
+                                     i++) {
+                                    var rHeaderExtension = remoteCapabilities.headerExtensions[i];
+                                    if (lHeaderExtension.uri === rHeaderExtension.uri) {
+                                        commonCapabilities.headerExtensions.push(rHeaderExtension);
+                                        break;
+                                    }
+                                }
+                            });
+
+                        // FIXME: fecMechanisms
+                        return commonCapabilities;
+                    };
+
+                // Create ICE gatherer, ICE transport and DTLS transport.
+                window.RTCPeerConnection.prototype._createIceAndDtlsTransports =
+                    function(mid, sdpMLineIndex) {
+                        var self = this;
+                        var iceGatherer = new RTCIceGatherer(self.iceOptions);
+                        var iceTransport = new RTCIceTransport(iceGatherer);
+                        iceGatherer.onlocalcandidate = function(evt) {
+                            var event = new Event('icecandidate');
+                            event.candidate = {sdpMid: mid, sdpMLineIndex: sdpMLineIndex};
+
+                            var cand = evt.candidate;
+                            var end = !cand || Object.keys(cand).length === 0;
+                            // Edge emits an empty object for RTCIceCandidateComplete‥
+                            if (end) {
+                                // polyfill since RTCIceGatherer.state is not implemented in
+                                // Edge 10547 yet.
+                                if (iceGatherer.state === undefined) {
+                                    iceGatherer.state = 'completed';
+                                }
+
+                                // Emit a candidate with type endOfCandidates to make the samples
+                                // work. Edge requires addIceCandidate with this empty candidate
+                                // to start checking. The real solution is to signal
+                                // end-of-candidates to the other side when getting the null
+                                // candidate but some apps (like the samples) don't do that.
+                                event.candidate.candidate =
+                                    'candidate:1 1 udp 1 0.0.0.0 9 typ endOfCandidates';
+                            } else {
+                                // RTCIceCandidate doesn't have a component, needs to be added
+                                cand.component = iceTransport.component === 'RTCP' ? 2 : 1;
+                                event.candidate.candidate = SDPUtils.writeCandidate(cand);
+                            }
+
+                            // update local description.
+                            var sections = SDPUtils.splitSections(self.localDescription.sdp);
+                            if (event.candidate.candidate.indexOf('typ endOfCandidates')
+                                === -1) {
+                                sections[event.candidate.sdpMLineIndex + 1] +=
+                                    'a=' + event.candidate.candidate + '\r\n';
+                            } else {
+                                sections[event.candidate.sdpMLineIndex + 1] +=
+                                    'a=end-of-candidates\r\n';
+                            }
+                            self.localDescription.sdp = sections.join('');
+
+                            var complete = self.transceivers.every(function(transceiver) {
+                                return transceiver.iceGatherer &&
+                                    transceiver.iceGatherer.state === 'completed';
+                            });
+
+                            // Emit candidate if localDescription is set.
+                            // Also emits null candidate when all gatherers are complete.
+                            switch (self.iceGatheringState) {
+                                case 'new':
+                                    self._localIceCandidatesBuffer.push(event);
+                                    if (end && complete) {
+                                        self._localIceCandidatesBuffer.push(
+                                            new Event('icecandidate'));
+                                    }
+                                    break;
+                                case 'gathering':
+                                    self._emitBufferedCandidates();
+                                    self.dispatchEvent(event);
+                                    if (self.onicecandidate !== null) {
+                                        self.onicecandidate(event);
+                                    }
+                                    if (complete) {
+                                        self.dispatchEvent(new Event('icecandidate'));
+                                        if (self.onicecandidate !== null) {
+                                            self.onicecandidate(new Event('icecandidate'));
+                                        }
+                                        self.iceGatheringState = 'complete';
+                                    }
+                                    break;
+                                case 'complete':
+                                    // should not happen... currently!
+                                    break;
+                                default: // no-op.
+                                    break;
+                            }
+                        };
+                        iceTransport.onicestatechange = function() {
+                            self._updateConnectionState();
+                        };
+
+                        var dtlsTransport = new RTCDtlsTransport(iceTransport);
+                        dtlsTransport.ondtlsstatechange = function() {
+                            self._updateConnectionState();
+                        };
+                        dtlsTransport.onerror = function() {
+                            // onerror does not set state to failed by itself.
+                            dtlsTransport.state = 'failed';
+                            self._updateConnectionState();
+                        };
+
+                        return {
+                            iceGatherer: iceGatherer,
+                            iceTransport: iceTransport,
+                            dtlsTransport: dtlsTransport
+                        };
+                    };
+
+                // Start the RTP Sender and Receiver for a transceiver.
+                window.RTCPeerConnection.prototype._transceive = function(transceiver,
+                                                                          send, recv) {
+                    var params = this._getCommonCapabilities(transceiver.localCapabilities,
+                        transceiver.remoteCapabilities);
+                    if (send && transceiver.rtpSender) {
+                        params.encodings = transceiver.sendEncodingParameters;
+                        params.rtcp = {
+                            cname: SDPUtils.localCName
+                        };
+                        if (transceiver.recvEncodingParameters.length) {
+                            params.rtcp.ssrc = transceiver.recvEncodingParameters[0].ssrc;
+                        }
+                        transceiver.rtpSender.send(params);
+                    }
+                    if (recv && transceiver.rtpReceiver) {
+                        // remove RTX field in Edge 14942
+                        if (transceiver.kind === 'video'
+                            && transceiver.recvEncodingParameters) {
+                            transceiver.recvEncodingParameters.forEach(function(p) {
+                                delete p.rtx;
+                            });
+                        }
+                        params.encodings = transceiver.recvEncodingParameters;
+                        params.rtcp = {
+                            cname: transceiver.cname
+                        };
+                        if (transceiver.sendEncodingParameters.length) {
+                            params.rtcp.ssrc = transceiver.sendEncodingParameters[0].ssrc;
+                        }
+                        transceiver.rtpReceiver.receive(params);
+                    }
+                };
+
+                window.RTCPeerConnection.prototype.setLocalDescription =
+                    function(description) {
+                        var self = this;
+                        var sections;
+                        var sessionpart;
+                        if (description.type === 'offer') {
+                            // FIXME: What was the purpose of this empty if statement?
+                            // if (!this._pendingOffer) {
+                            // } else {
+                            if (this._pendingOffer) {
+                                // VERY limited support for SDP munging. Limited to:
+                                // * changing the order of codecs
+                                sections = SDPUtils.splitSections(description.sdp);
+                                sessionpart = sections.shift();
+                                sections.forEach(function(mediaSection, sdpMLineIndex) {
+                                    var caps = SDPUtils.parseRtpParameters(mediaSection);
+                                    self._pendingOffer[sdpMLineIndex].localCapabilities = caps;
+                                });
+                                this.transceivers = this._pendingOffer;
+                                delete this._pendingOffer;
+                            }
+                        } else if (description.type === 'answer') {
+                            sections = SDPUtils.splitSections(self.remoteDescription.sdp);
+                            sessionpart = sections.shift();
+                            var isIceLite = SDPUtils.matchPrefix(sessionpart,
+                                'a=ice-lite').length > 0;
+                            sections.forEach(function(mediaSection, sdpMLineIndex) {
+                                var transceiver = self.transceivers[sdpMLineIndex];
+                                var iceGatherer = transceiver.iceGatherer;
+                                var iceTransport = transceiver.iceTransport;
+                                var dtlsTransport = transceiver.dtlsTransport;
+                                var localCapabilities = transceiver.localCapabilities;
+                                var remoteCapabilities = transceiver.remoteCapabilities;
+
+                                var rejected = mediaSection.split('\n', 1)[0]
+                                    .split(' ', 2)[1] === '0';
+
+                                if (!rejected && !transceiver.isDatachannel) {
+                                    var remoteIceParameters = SDPUtils.getIceParameters(
+                                        mediaSection, sessionpart);
+                                    if (isIceLite) {
+                                        var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')
+                                            .map(function(cand) {
+                                                return SDPUtils.parseCandidate(cand);
+                                            })
+                                            .filter(function(cand) {
+                                                return cand.component === '1';
+                                            });
+                                        // ice-lite only includes host candidates in the SDP so we can
+                                        // use setRemoteCandidates (which implies an
+                                        // RTCIceCandidateComplete)
+                                        if (cands.length) {
+                                            iceTransport.setRemoteCandidates(cands);
+                                        }
+                                    }
+                                    var remoteDtlsParameters = SDPUtils.getDtlsParameters(
+                                        mediaSection, sessionpart);
+                                    if (isIceLite) {
+                                        remoteDtlsParameters.role = 'server';
+                                    }
+
+                                    if (!self.usingBundle || sdpMLineIndex === 0) {
+                                        iceTransport.start(iceGatherer, remoteIceParameters,
+                                            isIceLite ? 'controlling' : 'controlled');
+                                        dtlsTransport.start(remoteDtlsParameters);
+                                    }
+
+                                    // Calculate intersection of capabilities.
+                                    var params = self._getCommonCapabilities(localCapabilities,
+                                        remoteCapabilities);
+
+                                    // Start the RTCRtpSender. The RTCRtpReceiver for this
+                                    // transceiver has already been started in setRemoteDescription.
+                                    self._transceive(transceiver,
+                                        params.codecs.length > 0,
+                                        false);
+                                }
+                            });
+                        }
+
+                        this.localDescription = {
+                            type: description.type,
+                            sdp: description.sdp
+                        };
+                        switch (description.type) {
+                            case 'offer':
+                                this._updateSignalingState('have-local-offer');
+                                break;
+                            case 'answer':
+                                this._updateSignalingState('stable');
+                                break;
+                            default:
+                                throw new TypeError('unsupported type "' + description.type +
+                                    '"');
+                        }
+
+                        // If a success callback was provided, emit ICE candidates after it
+                        // has been executed. Otherwise, emit callback after the Promise is
+                        // resolved.
+                        var hasCallback = arguments.length > 1 &&
+                            typeof arguments[1] === 'function';
+                        if (hasCallback) {
+                            var cb = arguments[1];
+                            window.setTimeout(function() {
+                                cb();
+                                if (self.iceGatheringState === 'new') {
+                                    self.iceGatheringState = 'gathering';
+                                }
+                                self._emitBufferedCandidates();
+                            }, 0);
+                        }
+                        var p = Promise.resolve();
+                        p.then(function() {
+                            if (!hasCallback) {
+                                if (self.iceGatheringState === 'new') {
+                                    self.iceGatheringState = 'gathering';
+                                }
+                                // Usually candidates will be emitted earlier.
+                                window.setTimeout(self._emitBufferedCandidates.bind(self), 500);
+                            }
+                        });
+                        return p;
+                    };
+
+                window.RTCPeerConnection.prototype.setRemoteDescription =
+                    function(description) {
+                        var self = this;
+                        var stream = new MediaStream();
+                        var receiverList = [];
+                        var sections = SDPUtils.splitSections(description.sdp);
+                        var sessionpart = sections.shift();
+                        var isIceLite = SDPUtils.matchPrefix(sessionpart,
+                            'a=ice-lite').length > 0;
+                        this.usingBundle = SDPUtils.matchPrefix(sessionpart,
+                            'a=group:BUNDLE ').length > 0;
+                        sections.forEach(function(mediaSection, sdpMLineIndex) {
+                            var lines = SDPUtils.splitLines(mediaSection);
+                            var mline = lines[0].substr(2).split(' ');
+                            var kind = mline[0];
+                            var rejected = mline[1] === '0';
+                            var direction = SDPUtils.getDirection(mediaSection, sessionpart);
+
+                            var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:');
+                            if (mid.length) {
+                                mid = mid[0].substr(6);
+                            } else {
+                                mid = SDPUtils.generateIdentifier();
+                            }
+
+                            // Reject datachannels which are not implemented yet.
+                            if (kind === 'application' && mline[2] === 'DTLS/SCTP') {
+                                self.transceivers[sdpMLineIndex] = {
+                                    mid: mid,
+                                    isDatachannel: true
+                                };
+                                return;
+                            }
+
+                            var transceiver;
+                            var iceGatherer;
+                            var iceTransport;
+                            var dtlsTransport;
+                            var rtpSender;
+                            var rtpReceiver;
+                            var sendEncodingParameters;
+                            var recvEncodingParameters;
+                            var localCapabilities;
+
+                            var track;
+                            // FIXME: ensure the mediaSection has rtcp-mux set.
+                            var remoteCapabilities = SDPUtils.parseRtpParameters(mediaSection);
+                            var remoteIceParameters;
+                            var remoteDtlsParameters;
+                            if (!rejected) {
+                                remoteIceParameters = SDPUtils.getIceParameters(mediaSection,
+                                    sessionpart);
+                                remoteDtlsParameters = SDPUtils.getDtlsParameters(mediaSection,
+                                    sessionpart);
+                                remoteDtlsParameters.role = 'client';
+                            }
+                            recvEncodingParameters =
+                                SDPUtils.parseRtpEncodingParameters(mediaSection);
+
+                            var cname;
+                            // Gets the first SSRC. Note that with RTX there might be multiple
+                            // SSRCs.
+                            var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+                                .map(function(line) {
+                                    return SDPUtils.parseSsrcMedia(line);
+                                })
+                                .filter(function(obj) {
+                                    return obj.attribute === 'cname';
+                                })[0];
+                            if (remoteSsrc) {
+                                cname = remoteSsrc.value;
+                            }
+
+                            var isComplete = SDPUtils.matchPrefix(mediaSection,
+                                'a=end-of-candidates', sessionpart).length > 0;
+                            var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')
+                                .map(function(cand) {
+                                    return SDPUtils.parseCandidate(cand);
+                                })
+                                .filter(function(cand) {
+                                    return cand.component === '1';
+                                });
+                            if (description.type === 'offer' && !rejected) {
+                                var transports = self.usingBundle && sdpMLineIndex > 0 ? {
+                                    iceGatherer: self.transceivers[0].iceGatherer,
+                                    iceTransport: self.transceivers[0].iceTransport,
+                                    dtlsTransport: self.transceivers[0].dtlsTransport
+                                } : self._createIceAndDtlsTransports(mid, sdpMLineIndex);
+
+                                if (isComplete) {
+                                    transports.iceTransport.setRemoteCandidates(cands);
+                                }
+
+                                localCapabilities = RTCRtpReceiver.getCapabilities(kind);
+
+                                // filter RTX until additional stuff needed for RTX is implemented
+                                // in adapter.js
+                                localCapabilities.codecs = localCapabilities.codecs.filter(
+                                    function(codec) {
+                                        return codec.name !== 'rtx';
+                                    });
+
+                                sendEncodingParameters = [{
+                                    ssrc: (2 * sdpMLineIndex + 2) * 1001
+                                }];
+
+                                rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);
+
+                                track = rtpReceiver.track;
+                                receiverList.push([track, rtpReceiver]);
+                                // FIXME: not correct when there are multiple streams but that is
+                                // not currently supported in this shim.
+                                stream.addTrack(track);
+
+                                // FIXME: look at direction.
+                                if (self.localStreams.length > 0 &&
+                                    self.localStreams[0].getTracks().length >= sdpMLineIndex) {
+                                    var localTrack;
+                                    if (kind === 'audio') {
+                                        localTrack = self.localStreams[0].getAudioTracks()[0];
+                                    } else if (kind === 'video') {
+                                        localTrack = self.localStreams[0].getVideoTracks()[0];
+                                    }
+                                    if (localTrack) {
+                                        rtpSender = new RTCRtpSender(localTrack,
+                                            transports.dtlsTransport);
+                                    }
+                                }
+
+                                self.transceivers[sdpMLineIndex] = {
+                                    iceGatherer: transports.iceGatherer,
+                                    iceTransport: transports.iceTransport,
+                                    dtlsTransport: transports.dtlsTransport,
+                                    localCapabilities: localCapabilities,
+                                    remoteCapabilities: remoteCapabilities,
+                                    rtpSender: rtpSender,
+                                    rtpReceiver: rtpReceiver,
+                                    kind: kind,
+                                    mid: mid,
+                                    cname: cname,
+                                    sendEncodingParameters: sendEncodingParameters,
+                                    recvEncodingParameters: recvEncodingParameters
+                                };
+                                // Start the RTCRtpReceiver now. The RTPSender is started in
+                                // setLocalDescription.
+                                self._transceive(self.transceivers[sdpMLineIndex],
+                                    false,
+                                    direction === 'sendrecv' || direction === 'sendonly');
+                            } else if (description.type === 'answer' && !rejected) {
+                                transceiver = self.transceivers[sdpMLineIndex];
+                                iceGatherer = transceiver.iceGatherer;
+                                iceTransport = transceiver.iceTransport;
+                                dtlsTransport = transceiver.dtlsTransport;
+                                rtpSender = transceiver.rtpSender;
+                                rtpReceiver = transceiver.rtpReceiver;
+                                sendEncodingParameters = transceiver.sendEncodingParameters;
+                                localCapabilities = transceiver.localCapabilities;
+
+                                self.transceivers[sdpMLineIndex].recvEncodingParameters =
+                                    recvEncodingParameters;
+                                self.transceivers[sdpMLineIndex].remoteCapabilities =
+                                    remoteCapabilities;
+                                self.transceivers[sdpMLineIndex].cname = cname;
+
+                                if ((isIceLite || isComplete) && cands.length) {
+                                    iceTransport.setRemoteCandidates(cands);
+                                }
+                                if (!self.usingBundle || sdpMLineIndex === 0) {
+                                    iceTransport.start(iceGatherer, remoteIceParameters,
+                                        'controlling');
+                                    dtlsTransport.start(remoteDtlsParameters);
+                                }
+
+                                self._transceive(transceiver,
+                                    direction === 'sendrecv' || direction === 'recvonly',
+                                    direction === 'sendrecv' || direction === 'sendonly');
+
+                                if (rtpReceiver &&
+                                    (direction === 'sendrecv' || direction === 'sendonly')) {
+                                    track = rtpReceiver.track;
+                                    receiverList.push([track, rtpReceiver]);
+                                    stream.addTrack(track);
+                                } else {
+                                    // FIXME: actually the receiver should be created later.
+                                    delete transceiver.rtpReceiver;
+                                }
+                            }
+                        });
+
+                        this.remoteDescription = {
+                            type: description.type,
+                            sdp: description.sdp
+                        };
+                        switch (description.type) {
+                            case 'offer':
+                                this._updateSignalingState('have-remote-offer');
+                                break;
+                            case 'answer':
+                                this._updateSignalingState('stable');
+                                break;
+                            default:
+                                throw new TypeError('unsupported type "' + description.type +
+                                    '"');
+                        }
+                        if (stream.getTracks().length) {
+                            self.remoteStreams.push(stream);
+                            window.setTimeout(function() {
+                                var event = new Event('addstream');
+                                event.stream = stream;
+                                self.dispatchEvent(event);
+                                if (self.onaddstream !== null) {
+                                    window.setTimeout(function() {
+                                        self.onaddstream(event);
+                                    }, 0);
+                                }
+
+                                receiverList.forEach(function(item) {
+                                    var track = item[0];
+                                    var receiver = item[1];
+                                    var trackEvent = new Event('track');
+                                    trackEvent.track = track;
+                                    trackEvent.receiver = receiver;
+                                    trackEvent.streams = [stream];
+                                    self.dispatchEvent(event);
+                                    if (self.ontrack !== null) {
+                                        window.setTimeout(function() {
+                                            self.ontrack(trackEvent);
+                                        }, 0);
+                                    }
+                                });
+                            }, 0);
+                        }
+                        if (arguments.length > 1 && typeof arguments[1] === 'function') {
+                            window.setTimeout(arguments[1], 0);
+                        }
+                        return Promise.resolve();
+                    };
+
+                window.RTCPeerConnection.prototype.close = function() {
+                    this.transceivers.forEach(function(transceiver) {
+                        /* not yet
+                        if (transceiver.iceGatherer) {
+                          transceiver.iceGatherer.close();
+                        }
+                        */
+                        if (transceiver.iceTransport) {
+                            transceiver.iceTransport.stop();
+                        }
+                        if (transceiver.dtlsTransport) {
+                            transceiver.dtlsTransport.stop();
+                        }
+                        if (transceiver.rtpSender) {
+                            transceiver.rtpSender.stop();
+                        }
+                        if (transceiver.rtpReceiver) {
+                            transceiver.rtpReceiver.stop();
+                        }
+                    });
+                    // FIXME: clean up tracks, local streams, remote streams, etc
+                    this._updateSignalingState('closed');
+                };
+
+                // Update the signaling state.
+                window.RTCPeerConnection.prototype._updateSignalingState =
+                    function(newState) {
+                        this.signalingState = newState;
+                        var event = new Event('signalingstatechange');
+                        this.dispatchEvent(event);
+                        if (this.onsignalingstatechange !== null) {
+                            this.onsignalingstatechange(event);
+                        }
+                    };
+
+                // Determine whether to fire the negotiationneeded event.
+                window.RTCPeerConnection.prototype._maybeFireNegotiationNeeded =
+                    function() {
+                        // Fire away (for now).
+                        var event = new Event('negotiationneeded');
+                        this.dispatchEvent(event);
+                        if (this.onnegotiationneeded !== null) {
+                            this.onnegotiationneeded(event);
+                        }
+                    };
+
+                // Update the connection state.
+                window.RTCPeerConnection.prototype._updateConnectionState = function() {
+                    var self = this;
+                    var newState;
+                    var states = {
+                        'new': 0,
+                        closed: 0,
+                        connecting: 0,
+                        checking: 0,
+                        connected: 0,
+                        completed: 0,
+                        failed: 0
+                    };
+                    this.transceivers.forEach(function(transceiver) {
+                        states[transceiver.iceTransport.state]++;
+                        states[transceiver.dtlsTransport.state]++;
+                    });
+                    // ICETransport.completed and connected are the same for this purpose.
+                    states.connected += states.completed;
+
+                    newState = 'new';
+                    if (states.failed > 0) {
+                        newState = 'failed';
+                    } else if (states.connecting > 0 || states.checking > 0) {
+                        newState = 'connecting';
+                    } else if (states.disconnected > 0) {
+                        newState = 'disconnected';
+                    } else if (states.new > 0) {
+                        newState = 'new';
+                    } else if (states.connected > 0 || states.completed > 0) {
+                        newState = 'connected';
+                    }
+
+                    if (newState !== self.iceConnectionState) {
+                        self.iceConnectionState = newState;
+                        var event = new Event('iceconnectionstatechange');
+                        this.dispatchEvent(event);
+                        if (this.oniceconnectionstatechange !== null) {
+                            this.oniceconnectionstatechange(event);
+                        }
+                    }
+                };
+
+                window.RTCPeerConnection.prototype.createOffer = function() {
+                    var self = this;
+                    if (this._pendingOffer) {
+                        throw new Error('createOffer called while there is a pending offer.');
+                    }
+                    var offerOptions;
+                    if (arguments.length === 1 && typeof arguments[0] !== 'function') {
+                        offerOptions = arguments[0];
+                    } else if (arguments.length === 3) {
+                        offerOptions = arguments[2];
+                    }
+
+                    var tracks = [];
+                    var numAudioTracks = 0;
+                    var numVideoTracks = 0;
+                    // Default to sendrecv.
+                    if (this.localStreams.length) {
+                        numAudioTracks = this.localStreams[0].getAudioTracks().length;
+                        numVideoTracks = this.localStreams[0].getVideoTracks().length;
+                    }
+                    // Determine number of audio and video tracks we need to send/recv.
+                    if (offerOptions) {
+                        // Reject Chrome legacy constraints.
+                        if (offerOptions.mandatory || offerOptions.optional) {
+                            throw new TypeError(
+                                'Legacy mandatory/optional constraints not supported.');
+                        }
+                        if (offerOptions.offerToReceiveAudio !== undefined) {
+                            numAudioTracks = offerOptions.offerToReceiveAudio;
+                        }
+                        if (offerOptions.offerToReceiveVideo !== undefined) {
+                            numVideoTracks = offerOptions.offerToReceiveVideo;
+                        }
+                    }
+                    if (this.localStreams.length) {
+                        // Push local streams.
+                        this.localStreams[0].getTracks().forEach(function(track) {
+                            tracks.push({
+                                kind: track.kind,
+                                track: track,
+                                wantReceive: track.kind === 'audio' ?
+                                    numAudioTracks > 0 : numVideoTracks > 0
+                            });
+                            if (track.kind === 'audio') {
+                                numAudioTracks--;
+                            } else if (track.kind === 'video') {
+                                numVideoTracks--;
+                            }
+                        });
+                    }
+                    // Create M-lines for recvonly streams.
+                    while (numAudioTracks > 0 || numVideoTracks > 0) {
+                        if (numAudioTracks > 0) {
+                            tracks.push({
+                                kind: 'audio',
+                                wantReceive: true
+                            });
+                            numAudioTracks--;
+                        }
+                        if (numVideoTracks > 0) {
+                            tracks.push({
+                                kind: 'video',
+                                wantReceive: true
+                            });
+                            numVideoTracks--;
+                        }
+                    }
+
+                    var sdp = SDPUtils.writeSessionBoilerplate();
+                    var transceivers = [];
+                    tracks.forEach(function(mline, sdpMLineIndex) {
+                        // For each track, create an ice gatherer, ice transport,
+                        // dtls transport, potentially rtpsender and rtpreceiver.
+                        var track = mline.track;
+                        var kind = mline.kind;
+                        var mid = SDPUtils.generateIdentifier();
+
+                        var transports = self.usingBundle && sdpMLineIndex > 0 ? {
+                            iceGatherer: transceivers[0].iceGatherer,
+                            iceTransport: transceivers[0].iceTransport,
+                            dtlsTransport: transceivers[0].dtlsTransport
+                        } : self._createIceAndDtlsTransports(mid, sdpMLineIndex);
+
+                        var localCapabilities = RTCRtpSender.getCapabilities(kind);
+                        // filter RTX until additional stuff needed for RTX is implemented
+                        // in adapter.js
+                        localCapabilities.codecs = localCapabilities.codecs.filter(
+                            function(codec) {
+                                return codec.name !== 'rtx';
+                            });
+
+                        var rtpSender;
+                        var rtpReceiver;
+
+                        // generate an ssrc now, to be used later in rtpSender.send
+                        var sendEncodingParameters = [{
+                            ssrc: (2 * sdpMLineIndex + 1) * 1001
+                        }];
+                        if (track) {
+                            rtpSender = new RTCRtpSender(track, transports.dtlsTransport);
+                        }
+
+                        if (mline.wantReceive) {
+                            rtpReceiver = new RTCRtpReceiver(transports.dtlsTransport, kind);
+                        }
+
+                        transceivers[sdpMLineIndex] = {
+                            iceGatherer: transports.iceGatherer,
+                            iceTransport: transports.iceTransport,
+                            dtlsTransport: transports.dtlsTransport,
+                            localCapabilities: localCapabilities,
+                            remoteCapabilities: null,
+                            rtpSender: rtpSender,
+                            rtpReceiver: rtpReceiver,
+                            kind: kind,
+                            mid: mid,
+                            sendEncodingParameters: sendEncodingParameters,
+                            recvEncodingParameters: null
+                        };
+                    });
+                    if (this.usingBundle) {
+                        sdp += 'a=group:BUNDLE ' + transceivers.map(function(t) {
+                            return t.mid;
+                        }).join(' ') + '\r\n';
+                    }
+                    tracks.forEach(function(mline, sdpMLineIndex) {
+                        var transceiver = transceivers[sdpMLineIndex];
+                        sdp += SDPUtils.writeMediaSection(transceiver,
+                            transceiver.localCapabilities, 'offer', self.localStreams[0]);
+                    });
+
+                    this._pendingOffer = transceivers;
+                    var desc = new RTCSessionDescription({
+                        type: 'offer',
+                        sdp: sdp
+                    });
+                    if (arguments.length && typeof arguments[0] === 'function') {
+                        window.setTimeout(arguments[0], 0, desc);
+                    }
+                    return Promise.resolve(desc);
+                };
+
+                window.RTCPeerConnection.prototype.createAnswer = function() {
+                    var self = this;
+
+                    var sdp = SDPUtils.writeSessionBoilerplate();
+                    if (this.usingBundle) {
+                        sdp += 'a=group:BUNDLE ' + this.transceivers.map(function(t) {
+                            return t.mid;
+                        }).join(' ') + '\r\n';
+                    }
+                    this.transceivers.forEach(function(transceiver) {
+                        if (transceiver.isDatachannel) {
+                            sdp += 'm=application 0 DTLS/SCTP 5000\r\n' +
+                                'c=IN IP4 0.0.0.0\r\n' +
+                                'a=mid:' + transceiver.mid + '\r\n';
+                            return;
+                        }
+                        // Calculate intersection of capabilities.
+                        var commonCapabilities = self._getCommonCapabilities(
+                            transceiver.localCapabilities,
+                            transceiver.remoteCapabilities);
+
+                        sdp += SDPUtils.writeMediaSection(transceiver, commonCapabilities,
+                            'answer', self.localStreams[0]);
+                    });
+
+                    var desc = new RTCSessionDescription({
+                        type: 'answer',
+                        sdp: sdp
+                    });
+                    if (arguments.length && typeof arguments[0] === 'function') {
+                        window.setTimeout(arguments[0], 0, desc);
+                    }
+                    return Promise.resolve(desc);
+                };
+
+                window.RTCPeerConnection.prototype.addIceCandidate = function(candidate) {
+                    if (candidate === null) {
+                        this.transceivers.forEach(function(transceiver) {
+                            transceiver.iceTransport.addRemoteCandidate({});
+                        });
+                    } else {
+                        var mLineIndex = candidate.sdpMLineIndex;
+                        if (candidate.sdpMid) {
+                            for (var i = 0; i < this.transceivers.length; i++) {
+                                if (this.transceivers[i].mid === candidate.sdpMid) {
+                                    mLineIndex = i;
+                                    break;
+                                }
+                            }
+                        }
+                        var transceiver = this.transceivers[mLineIndex];
+                        if (transceiver) {
+                            var cand = Object.keys(candidate.candidate).length > 0 ?
+                                SDPUtils.parseCandidate(candidate.candidate) : {};
+                            // Ignore Chrome's invalid candidates since Edge does not like them.
+                            if (cand.protocol === 'tcp' && (cand.port === 0 || cand.port === 9)) {
+                                return;
+                            }
+                            // Ignore RTCP candidates, we assume RTCP-MUX.
+                            if (cand.component !== '1') {
+                                return;
+                            }
+                            // A dirty hack to make samples work.
+                            if (cand.type === 'endOfCandidates') {
+                                cand = {};
+                            }
+                            transceiver.iceTransport.addRemoteCandidate(cand);
+
+                            // update the remoteDescription.
+                            var sections = SDPUtils.splitSections(this.remoteDescription.sdp);
+                            sections[mLineIndex + 1] += (cand.type ? candidate.candidate.trim()
+                                : 'a=end-of-candidates') + '\r\n';
+                            this.remoteDescription.sdp = sections.join('');
+                        }
+                    }
+                    if (arguments.length > 1 && typeof arguments[1] === 'function') {
+                        window.setTimeout(arguments[1], 0);
+                    }
+                    return Promise.resolve();
+                };
+
+                window.RTCPeerConnection.prototype.getStats = function() {
+                    var promises = [];
+                    this.transceivers.forEach(function(transceiver) {
+                        ['rtpSender', 'rtpReceiver', 'iceGatherer', 'iceTransport',
+                            'dtlsTransport'].forEach(function(method) {
+                            if (transceiver[method]) {
+                                promises.push(transceiver[method].getStats());
+                            }
+                        });
+                    });
+                    var cb = arguments.length > 1 && typeof arguments[1] === 'function' &&
+                        arguments[1];
+                    return new Promise(function(resolve) {
+                        // shim getStats with maplike support
+                        var results = new Map();
+                        Promise.all(promises).then(function(res) {
+                            res.forEach(function(result) {
+                                Object.keys(result).forEach(function(id) {
+                                    results.set(id, result[id]);
+                                    results[id] = result[id];
+                                });
+                            });
+                            if (cb) {
+                                window.setTimeout(cb, 0, results);
+                            }
+                            resolve(results);
+                        });
+                    });
+                };
+            }
+        };
+
+// Expose public methods.
+        module.exports = {
+            shimPeerConnection: edgeShim.shimPeerConnection,
+            shimGetUserMedia: require('./getusermedia')
+        };
+
+    },{"../utils":10,"./getusermedia":6,"sdp":1}],6:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+
+// Expose public methods.
+        module.exports = function() {
+            var shimError_ = function(e) {
+                return {
+                    name: {PermissionDeniedError: 'NotAllowedError'}[e.name] || e.name,
+                    message: e.message,
+                    constraint: e.constraint,
+                    toString: function() {
+                        return this.name;
+                    }
+                };
+            };
+
+            // getUserMedia error shim.
+            var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+            bind(navigator.mediaDevices);
+            navigator.mediaDevices.getUserMedia = function(c) {
+                return origGetUserMedia(c).catch(function(e) {
+                    return Promise.reject(shimError_(e));
+                });
+            };
+        };
+
+    },{}],7:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+
+        var browserDetails = require('../utils').browserDetails;
+
+        var firefoxShim = {
+            shimOnTrack: function() {
+                if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
+                    window.RTCPeerConnection.prototype)) {
+                    Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
+                        get: function() {
+                            return this._ontrack;
+                        },
+                        set: function(f) {
+                            if (this._ontrack) {
+                                this.removeEventListener('track', this._ontrack);
+                                this.removeEventListener('addstream', this._ontrackpoly);
+                            }
+                            this.addEventListener('track', this._ontrack = f);
+                            this.addEventListener('addstream', this._ontrackpoly = function(e) {
+                                e.stream.getTracks().forEach(function(track) {
+                                    var event = new Event('track');
+                                    event.track = track;
+                                    event.receiver = {track: track};
+                                    event.streams = [e.stream];
+                                    this.dispatchEvent(event);
+                                }.bind(this));
+                            }.bind(this));
+                        }
+                    });
+                }
+            },
+
+            shimSourceObject: function() {
+                // Firefox has supported mozSrcObject since FF22, unprefixed in 42.
+                if (typeof window === 'object') {
+                    if (window.HTMLMediaElement &&
+                        !('srcObject' in window.HTMLMediaElement.prototype)) {
+                        // Shim the srcObject property, once, when HTMLMediaElement is found.
+                        Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
+                            get: function() {
+                                return this.mozSrcObject;
+                            },
+                            set: function(stream) {
+                                this.mozSrcObject = stream;
+                            }
+                        });
+                    }
+                }
+            },
+
+            shimPeerConnection: function() {
+                if (typeof window !== 'object' || !(window.RTCPeerConnection ||
+                    window.mozRTCPeerConnection)) {
+                    return; // probably media.peerconnection.enabled=false in about:config
+                }
+                // The RTCPeerConnection object.
+                if (!window.RTCPeerConnection) {
+                    window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+                        if (browserDetails.version < 38) {
+                            // .urls is not supported in FF < 38.
+                            // create RTCIceServers with a single url.
+                            if (pcConfig && pcConfig.iceServers) {
+                                var newIceServers = [];
+                                for (var i = 0; i < pcConfig.iceServers.length; i++) {
+                                    var server = pcConfig.iceServers[i];
+                                    if (server.hasOwnProperty('urls')) {
+                                        for (var j = 0; j < server.urls.length; j++) {
+                                            var newServer = {
+                                                url: server.urls[j]
+                                            };
+                                            if (server.urls[j].indexOf('turn') === 0) {
+                                                newServer.username = server.username;
+                                                newServer.credential = server.credential;
+                                            }
+                                            newIceServers.push(newServer);
+                                        }
+                                    } else {
+                                        newIceServers.push(pcConfig.iceServers[i]);
+                                    }
+                                }
+                                pcConfig.iceServers = newIceServers;
+                            }
+                        }
+                        return new mozRTCPeerConnection(pcConfig, pcConstraints);
+                    };
+                    window.RTCPeerConnection.prototype = mozRTCPeerConnection.prototype;
+
+                    // wrap static methods. Currently just generateCertificate.
+                    if (mozRTCPeerConnection.generateCertificate) {
+                        Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                            get: function() {
+                                return mozRTCPeerConnection.generateCertificate;
+                            }
+                        });
+                    }
+
+                    window.RTCSessionDescription = mozRTCSessionDescription;
+                    window.RTCIceCandidate = mozRTCIceCandidate;
+                }
+
+                // shim away need for obsolete RTCIceCandidate/RTCSessionDescription.
+                ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+                    .forEach(function(method) {
+                        var nativeMethod = RTCPeerConnection.prototype[method];
+                        RTCPeerConnection.prototype[method] = function() {
+                            arguments[0] = new ((method === 'addIceCandidate') ?
+                                RTCIceCandidate : RTCSessionDescription)(arguments[0]);
+                            return nativeMethod.apply(this, arguments);
+                        };
+                    });
+
+                // support for addIceCandidate(null)
+                var nativeAddIceCandidate =
+                    RTCPeerConnection.prototype.addIceCandidate;
+                RTCPeerConnection.prototype.addIceCandidate = function() {
+                    return arguments[0] === null ? Promise.resolve()
+                        : nativeAddIceCandidate.apply(this, arguments);
+                };
+
+                // shim getStats with maplike support
+                var makeMapStats = function(stats) {
+                    var map = new Map();
+                    Object.keys(stats).forEach(function(key) {
+                        map.set(key, stats[key]);
+                        map[key] = stats[key];
+                    });
+                    return map;
+                };
+
+                var nativeGetStats = RTCPeerConnection.prototype.getStats;
+                RTCPeerConnection.prototype.getStats = function(selector, onSucc, onErr) {
+                    return nativeGetStats.apply(this, [selector || null])
+                        .then(function(stats) {
+                            return makeMapStats(stats);
+                        })
+                        .then(onSucc, onErr);
+                };
+            }
+        };
+
+// Expose public methods.
+        module.exports = {
+            shimOnTrack: firefoxShim.shimOnTrack,
+            shimSourceObject: firefoxShim.shimSourceObject,
+            shimPeerConnection: firefoxShim.shimPeerConnection,
+            shimGetUserMedia: require('./getusermedia')
+        };
+
+    },{"../utils":10,"./getusermedia":8}],8:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+
+        var logging = require('../utils').log;
+        var browserDetails = require('../utils').browserDetails;
+
+// Expose public methods.
+        module.exports = function() {
+            var shimError_ = function(e) {
+                return {
+                    name: {
+                        SecurityError: 'NotAllowedError',
+                        PermissionDeniedError: 'NotAllowedError'
+                    }[e.name] || e.name,
+                    message: {
+                        'The operation is insecure.': 'The request is not allowed by the ' +
+                            'user agent or the platform in the current context.'
+                    }[e.message] || e.message,
+                    constraint: e.constraint,
+                    toString: function() {
+                        return this.name + (this.message && ': ') + this.message;
+                    }
+                };
+            };
+
+            // getUserMedia constraints shim.
+            var getUserMedia_ = function(constraints, onSuccess, onError) {
+                var constraintsToFF37_ = function(c) {
+                    if (typeof c !== 'object' || c.require) {
+                        return c;
+                    }
+                    var require = [];
+                    Object.keys(c).forEach(function(key) {
+                        if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
+                            return;
+                        }
+                        var r = c[key] = (typeof c[key] === 'object') ?
+                            c[key] : {ideal: c[key]};
+                        if (r.min !== undefined ||
+                            r.max !== undefined || r.exact !== undefined) {
+                            require.push(key);
+                        }
+                        if (r.exact !== undefined) {
+                            if (typeof r.exact === 'number') {
+                                r. min = r.max = r.exact;
+                            } else {
+                                c[key] = r.exact;
+                            }
+                            delete r.exact;
+                        }
+                        if (r.ideal !== undefined) {
+                            c.advanced = c.advanced || [];
+                            var oc = {};
+                            if (typeof r.ideal === 'number') {
+                                oc[key] = {min: r.ideal, max: r.ideal};
+                            } else {
+                                oc[key] = r.ideal;
+                            }
+                            c.advanced.push(oc);
+                            delete r.ideal;
+                            if (!Object.keys(r).length) {
+                                delete c[key];
+                            }
+                        }
+                    });
+                    if (require.length) {
+                        c.require = require;
+                    }
+                    return c;
+                };
+                constraints = JSON.parse(JSON.stringify(constraints));
+                if (browserDetails.version < 38) {
+                    logging('spec: ' + JSON.stringify(constraints));
+                    if (constraints.audio) {
+                        constraints.audio = constraintsToFF37_(constraints.audio);
+                    }
+                    if (constraints.video) {
+                        constraints.video = constraintsToFF37_(constraints.video);
+                    }
+                    logging('ff37: ' + JSON.stringify(constraints));
+                }
+                return navigator.mozGetUserMedia(constraints, onSuccess, function(e) {
+                    onError(shimError_(e));
+                });
+            };
+
+            // Returns the result of getUserMedia as a Promise.
+            var getUserMediaPromise_ = function(constraints) {
+                return new Promise(function(resolve, reject) {
+                    getUserMedia_(constraints, resolve, reject);
+                });
+            };
+
+            // Shim for mediaDevices on older versions.
+            if (!navigator.mediaDevices) {
+                navigator.mediaDevices = {getUserMedia: getUserMediaPromise_,
+                    addEventListener: function() { },
+                    removeEventListener: function() { }
+                };
+            }
+            navigator.mediaDevices.enumerateDevices =
+                navigator.mediaDevices.enumerateDevices || function() {
+                    return new Promise(function(resolve) {
+                        var infos = [
+                            {kind: 'audioinput', deviceId: 'default', label: '', groupId: ''},
+                            {kind: 'videoinput', deviceId: 'default', label: '', groupId: ''}
+                        ];
+                        resolve(infos);
+                    });
+                };
+
+            if (browserDetails.version < 41) {
+                // Work around http://bugzil.la/1169665
+                var orgEnumerateDevices =
+                    navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+                navigator.mediaDevices.enumerateDevices = function() {
+                    return orgEnumerateDevices().then(undefined, function(e) {
+                        if (e.name === 'NotFoundError') {
+                            return [];
+                        }
+                        throw e;
+                    });
+                };
+            }
+            if (browserDetails.version < 49) {
+                var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+                bind(navigator.mediaDevices);
+                navigator.mediaDevices.getUserMedia = function(c) {
+                    return origGetUserMedia(c).then(function(stream) {
+                        // Work around https://bugzil.la/802326
+                        if (c.audio && !stream.getAudioTracks().length ||
+                            c.video && !stream.getVideoTracks().length) {
+                            stream.getTracks().forEach(function(track) {
+                                track.stop();
+                            });
+                            throw new DOMException('The object can not be found here.',
+                                'NotFoundError');
+                        }
+                        return stream;
+                    }, function(e) {
+                        return Promise.reject(shimError_(e));
+                    });
+                };
+            }
+            navigator.getUserMedia = function(constraints, onSuccess, onError) {
+                if (browserDetails.version < 44) {
+                    return getUserMedia_(constraints, onSuccess, onError);
+                }
+                // Replace Firefox 44+'s deprecation warning with unprefixed version.
+                console.warn('navigator.getUserMedia has been replaced by ' +
+                    'navigator.mediaDevices.getUserMedia');
+                navigator.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);
+            };
+        };
+
+    },{"../utils":10}],9:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        'use strict';
+        var safariShim = {
+            // TODO: DrAlex, should be here, double check against LayoutTests
+            // shimOnTrack: function() { },
+
+            // TODO: once the back-end for the mac port is done, add.
+            // TODO: check for webkitGTK+
+            // shimPeerConnection: function() { },
+
+            shimGetUserMedia: function() {
+                navigator.getUserMedia = navigator.webkitGetUserMedia;
+            }
+        };
+
+// Expose public methods.
+        module.exports = {
+            shimGetUserMedia: safariShim.shimGetUserMedia
+            // TODO
+            // shimOnTrack: safariShim.shimOnTrack,
+            // shimPeerConnection: safariShim.shimPeerConnection
+        };
+
+    },{}],10:[function(require,module,exports){
+        /*
+         *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+         *
+         *  Use of this source code is governed by a BSD-style license
+         *  that can be found in the LICENSE file in the root of the source
+         *  tree.
+         */
+        /* eslint-env node */
+        'use strict';
+
+        var logDisabled_ = true;
+
+// Utility methods.
+        var utils = {
+            disableLog: function(bool) {
+                if (typeof bool !== 'boolean') {
+                    return new Error('Argument type: ' + typeof bool +
+                        '. Please use a boolean.');
+                }
+                logDisabled_ = bool;
+                return (bool) ? 'adapter.js logging disabled' :
+                    'adapter.js logging enabled';
+            },
+
+            log: function() {
+                if (typeof window === 'object') {
+                    if (logDisabled_) {
+                        return;
+                    }
+                    if (typeof console !== 'undefined' && typeof console.log === 'function') {
+                        console.log.apply(console, arguments);
+                    }
+                }
+            },
+
+            /**
+             * Extract browser version out of the provided user agent string.
+             *
+             * @param {!string} uastring userAgent string.
+             * @param {!string} expr Regular expression used as match criteria.
+             * @param {!number} pos position in the version string to be returned.
+             * @return {!number} browser version.
+             */
+            extractVersion: function(uastring, expr, pos) {
+                var match = uastring.match(expr);
+                return match && match.length >= pos && parseInt(match[pos], 10);
+            },
+
+            /**
+             * Browser detector.
+             *
+             * @return {object} result containing browser and version
+             *     properties.
+             */
+            detectBrowser: function() {
+                // Returned result object.
+                var result = {};
+                result.browser = null;
+                result.version = null;
+
+                // Fail early if it's not a browser
+                if (typeof window === 'undefined' || !window.navigator) {
+                    result.browser = 'Not a browser.';
+                    return result;
+                }
+
+                // Firefox.
+                if (navigator.mozGetUserMedia) {
+                    result.browser = 'firefox';
+                    result.version = this.extractVersion(navigator.userAgent,
+                        /Firefox\/([0-9]+)\./, 1);
+
+                    // all webkit-based browsers
+                } else if (navigator.webkitGetUserMedia) {
+                    // Chrome, Chromium, Webview, Opera, all use the chrome shim for now
+                    if (window.webkitRTCPeerConnection) {
+                        result.browser = 'chrome';
+                        result.version = this.extractVersion(navigator.userAgent,
+                            /Chrom(e|ium)\/([0-9]+)\./, 2);
+
+                        // Safari or unknown webkit-based
+                        // for the time being Safari has support for MediaStreams but not webRTC
+                    } else {
+                        // Safari UA substrings of interest for reference:
+                        // - webkit version:           AppleWebKit/602.1.25 (also used in Op,Cr)
+                        // - safari UI version:        Version/9.0.3 (unique to Safari)
+                        // - safari UI webkit version: Safari/601.4.4 (also used in Op,Cr)
+                        //
+                        // if the webkit version and safari UI webkit versions are equals,
+                        // ... this is a stable version.
+                        //
+                        // only the internal webkit version is important today to know if
+                        // media streams are supported
+                        //
+                        if (navigator.userAgent.match(/Version\/(\d+).(\d+)/)) {
+                            result.browser = 'safari';
+                            result.version = this.extractVersion(navigator.userAgent,
+                                /AppleWebKit\/([0-9]+)\./, 1);
+
+                            // unknown webkit-based browser
+                        } else {
+                            result.browser = 'Unsupported webkit-based browser ' +
+                                'with GUM support but no WebRTC support.';
+                            return result;
+                        }
+                    }
+
+                    // Edge.
+                } else if (navigator.mediaDevices &&
+                    navigator.userAgent.match(/Edge\/(\d+).(\d+)$/)) {
+                    result.browser = 'edge';
+                    result.version = this.extractVersion(navigator.userAgent,
+                        /Edge\/(\d+).(\d+)$/, 2);
+
+                    // Default fallthrough: not supported.
+                } else {
+                    result.browser = 'Not a supported browser.';
+                    return result;
+                }
+
+                return result;
+            }
+        };
+
+// Export.
+        module.exports = {
+            log: utils.log,
+            disableLog: utils.disableLog,
+            browserDetails: utils.detectBrowser(),
+            extractVersion: utils.extractVersion
+        };
+
+    },{}]},{},[2])(2)
+});
diff --git a/src/lib/janus.js b/src/lib/janus.js
new file mode 100644
index 0000000..0b4c436
--- /dev/null
+++ b/src/lib/janus.js
@@ -0,0 +1,3456 @@
+/*
+	The MIT License (MIT)
+
+	Copyright (c) 2016 Meetecho
+
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of this software and associated documentation files (the "Software"),
+	to deal in the Software without restriction, including without limitation
+	the rights to use, copy, modify, merge, publish, distribute, sublicense,
+	and/or sell copies of the Software, and to permit persons to whom the
+	Software is furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included
+	in all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+	THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+	OTHER DEALINGS IN THE SOFTWARE.
+ */
+/* eslint-disable */
+var adapter = require("./adapter");
+var jQuery = require("jquery")
+Janus.sessions = {};
+
+Janus.isExtensionEnabled = function() {
+	if(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
+		// No need for the extension, getDisplayMedia is supported
+		return true;
+	}
+	if(window.navigator.userAgent.match('Chrome')) {
+		var chromever = parseInt(window.navigator.userAgent.match(/Chrome\/(.*) /)[1], 10);
+		var maxver = 33;
+		if(window.navigator.userAgent.match('Linux'))
+			maxver = 35;	// "known" crash in chrome 34 and 35 on linux
+		if(chromever >= 26 && chromever <= maxver) {
+			// Older versions of Chrome don't support this extension-based approach, so lie
+			return true;
+		}
+		return Janus.extension.isInstalled();
+	} else {
+		// Firefox of others, no need for the extension (but this doesn't mean it will work)
+		return true;
+	}
+};
+
+var defaultExtension = {
+	// Screensharing Chrome Extension ID
+	extensionId: 'hapfgfdkleiggjjpfpenajgdnfckjpaj',
+	isInstalled: function() { return document.querySelector('#janus-extension-installed') !== null; },
+	getScreen: function (callback) {
+		var pending = window.setTimeout(function () {
+			var error = new Error('NavigatorUserMediaError');
+			error.name = 'The required Chrome extension is not installed: click <a href="#">here</a> to install it. (NOTE: this will need you to refresh the page)';
+			return callback(error);
+		}, 1000);
+		this.cache[pending] = callback;
+		window.postMessage({ type: 'janusGetScreen', id: pending }, '*');
+	},
+	init: function () {
+		var cache = {};
+		this.cache = cache;
+		// Wait for events from the Chrome Extension
+		window.addEventListener('message', function (event) {
+			if(event.origin != window.location.origin)
+				return;
+			if(event.data.type == 'janusGotScreen' && cache[event.data.id]) {
+				var callback = cache[event.data.id];
+				delete cache[event.data.id];
+
+				if (event.data.sourceId === '') {
+					// user canceled
+					var error = new Error('NavigatorUserMediaError');
+					error.name = 'You cancelled the request for permission, giving up...';
+					callback(error);
+				} else {
+					callback(null, event.data.sourceId);
+				}
+			} else if (event.data.type == 'janusGetScreenPending') {
+				console.log('clearing ', event.data.id);
+				window.clearTimeout(event.data.id);
+			}
+		});
+	}
+};
+
+Janus.useDefaultDependencies = function (deps) {
+	var f = (deps && deps.fetch) || fetch;
+	var p = (deps && deps.Promise) || Promise;
+	var socketCls = (deps && deps.WebSocket) || WebSocket;
+
+	return {
+		newWebSocket: function(server, proto) { return new socketCls(server, proto); },
+		extension: (deps && deps.extension) || defaultExtension,
+		isArray: function(arr) { return Array.isArray(arr); },
+		webRTCAdapter: (deps && deps.adapter) || adapter,
+		httpAPICall: function(url, options) {
+			var fetchOptions = {
+				method: options.verb,
+				headers: {
+					'Accept': 'application/json, text/plain, */*'
+				},
+				cache: 'no-cache'
+			};
+			if(options.verb === "POST") {
+				fetchOptions.headers['Content-Type'] = 'application/json';
+			}
+			if(options.withCredentials !== undefined) {
+				fetchOptions.credentials = options.withCredentials === true ? 'include' : (options.withCredentials ? options.withCredentials : 'omit');
+			}
+			if(options.body) {
+				fetchOptions.body = JSON.stringify(options.body);
+			}
+
+			var fetching = f(url, fetchOptions).catch(function(error) {
+				return p.reject({message: 'Probably a network error, is the server down?', error: error});
+			});
+
+			/*
+			 * fetch() does not natively support timeouts.
+			 * Work around this by starting a timeout manually, and racing it agains the fetch() to see which thing resolves first.
+			 */
+
+			if(options.timeout) {
+				var timeout = new p(function(resolve, reject) {
+					var timerId = setTimeout(function() {
+						clearTimeout(timerId);
+						return reject({message: 'Request timed out', timeout: options.timeout});
+					}, options.timeout);
+				});
+				fetching = p.race([fetching,timeout]);
+			}
+
+			fetching.then(function(response) {
+				if(response.ok) {
+					if(typeof(options.success) === typeof(Janus.noop)) {
+						return response.json().then(function(parsed) {
+							options.success(parsed);
+						}).catch(function(error) {
+							return p.reject({message: 'Failed to parse response body', error: error, response: response});
+						});
+					}
+				}
+				else {
+					return p.reject({message: 'API call failed', response: response});
+				}
+			}).catch(function(error) {
+				if(typeof(options.error) === typeof(Janus.noop)) {
+					options.error(error.message || '<< internal error >>', error);
+				}
+			});
+
+			return fetching;
+		}
+	}
+};
+
+Janus.useOldDependencies = function (deps) {
+	var jq = (deps && deps.jQuery) || jQuery;
+	var socketCls = (deps && deps.WebSocket) || WebSocket;
+	return {
+		newWebSocket: function(server, proto) { return new socketCls(server, proto); },
+		isArray: function(arr) { return jq.isArray(arr); },
+		extension: (deps && deps.extension) || defaultExtension,
+		webRTCAdapter: (deps && deps.adapter) || adapter,
+		httpAPICall: function(url, options) {
+			var payload = options.body !== undefined ? {
+				contentType: 'application/json',
+				data: JSON.stringify(options.body)
+			} : {};
+			var credentials = options.withCredentials !== undefined ? {xhrFields: {withCredentials: options.withCredentials}} : {};
+
+			return jq.ajax(jq.extend(payload, credentials, {
+				url: url,
+				type: options.verb,
+				cache: false,
+				dataType: 'json',
+				async: options.async,
+				timeout: options.timeout,
+				success: function(result) {
+					if(typeof(options.success) === typeof(Janus.noop)) {
+						options.success(result);
+					}
+				},
+				error: function(xhr, status, err) {
+					if(typeof(options.error) === typeof(Janus.noop)) {
+						options.error(status, err);
+					}
+				}
+			}));
+		},
+	};
+};
+
+Janus.noop = function() {};
+
+Janus.dataChanDefaultLabel = "JanusDataChannel";
+
+// Note: in the future we may want to change this, e.g., as was
+// attempted in https://github.com/meetecho/janus-gateway/issues/1670
+Janus.endOfCandidates = null;
+
+// Initialization
+Janus.init = function(options) {
+	options = options || {};
+	options.callback = (typeof options.callback == "function") ? options.callback : Janus.noop;
+	if(Janus.initDone) {
+		// Already initialized
+		options.callback();
+	} else {
+		if(typeof console == "undefined" || typeof console.log == "undefined")
+			console = { log: function() {} };
+		// Console logging (all debugging disabled by default)
+		Janus.trace = Janus.noop;
+		Janus.debug = Janus.noop;
+		Janus.vdebug = Janus.noop;
+		Janus.log = Janus.noop;
+		Janus.warn = Janus.noop;
+		Janus.error = Janus.noop;
+		if(options.debug === true || options.debug === "all") {
+			// Enable all debugging levels
+			Janus.trace = console.trace.bind(console);
+			Janus.debug = console.debug.bind(console);
+			Janus.vdebug = console.debug.bind(console);
+			Janus.log = console.log.bind(console);
+			Janus.warn = console.warn.bind(console);
+			Janus.error = console.error.bind(console);
+		} else if(Array.isArray(options.debug)) {
+			for(var d of options.debug) {
+				switch(d) {
+					case "trace":
+						Janus.trace = console.trace.bind(console);
+						break;
+					case "debug":
+						Janus.debug = console.debug.bind(console);
+						break;
+					case "vdebug":
+						Janus.vdebug = console.debug.bind(console);
+						break;
+					case "log":
+						Janus.log = console.log.bind(console);
+						break;
+					case "warn":
+						Janus.warn = console.warn.bind(console);
+						break;
+					case "error":
+						Janus.error = console.error.bind(console);
+						break;
+					default:
+						console.error("Unknown debugging option '" + d + "' (supported: 'trace', 'debug', 'vdebug', 'log', warn', 'error')");
+						break;
+				}
+			}
+		}
+		Janus.log("Initializing library");
+
+		var usedDependencies = options.dependencies || Janus.useDefaultDependencies();
+		Janus.isArray = usedDependencies.isArray;
+		Janus.webRTCAdapter = usedDependencies.webRTCAdapter;
+		Janus.httpAPICall = usedDependencies.httpAPICall;
+		Janus.newWebSocket = usedDependencies.newWebSocket;
+		Janus.extension = usedDependencies.extension;
+		Janus.extension.init();
+
+		// Helper method to enumerate devices
+		Janus.listDevices = function(callback, config) {
+			callback = (typeof callback == "function") ? callback : Janus.noop;
+			if (config == null) config = { audio: true, video: true };
+			if(Janus.isGetUserMediaAvailable()) {
+				navigator.mediaDevices.getUserMedia(config)
+					.then(function(stream) {
+						navigator.mediaDevices.enumerateDevices().then(function(devices) {
+							Janus.debug(devices);
+							callback(devices);
+							// Get rid of the now useless stream
+							try {
+								var tracks = stream.getTracks();
+								for(var mst of tracks) {
+									if(mst)
+										mst.stop();
+								}
+							} catch(e) {}
+						});
+					})
+					.catch(function(err) {
+						Janus.error(err);
+						callback([]);
+					});
+			} else {
+				Janus.warn("navigator.mediaDevices unavailable");
+				callback([]);
+			}
+		}
+		// Helper methods to attach/reattach a stream to a video element (previously part of adapter.js)
+		Janus.attachMediaStream = function(element, stream) {
+			try {
+				element.srcObject = stream;
+			} catch (e) {
+				try {
+					element.src = URL.createObjectURL(stream);
+				} catch (e) {
+					Janus.error("Error attaching stream to element");
+				}
+			}
+		};
+		Janus.reattachMediaStream = function(to, from) {
+			try {
+				to.srcObject = from.srcObject;
+			} catch (e) {
+				try {
+					to.src = from.src;
+				} catch (e) {
+					Janus.error("Error reattaching stream to element");
+				}
+			}
+		};
+		// Detect tab close: make sure we don't loose existing onbeforeunload handlers
+		// (note: for iOS we need to subscribe to a different event, 'pagehide', see
+		// https://gist.github.com/thehunmonkgroup/6bee8941a49b86be31a787fe8f4b8cfe)
+		var iOS = ['iPad', 'iPhone', 'iPod'].indexOf(navigator.platform) >= 0;
+		var eventName = iOS ? 'pagehide' : 'beforeunload';
+		var oldOBF = window["on" + eventName];
+		window.addEventListener(eventName, function(event) {
+			Janus.log("Closing window");
+			for(var s in Janus.sessions) {
+				if(Janus.sessions[s] && Janus.sessions[s].destroyOnUnload) {
+					Janus.log("Destroying session " + s);
+					Janus.sessions[s].destroy({unload: true, notifyDestroyed: false});
+				}
+			}
+			if(oldOBF && typeof oldOBF == "function")
+				oldOBF();
+		});
+		// If this is a Safari Technology Preview, check if VP8 is supported
+		Janus.safariVp8 = false;
+		if(Janus.webRTCAdapter.browserDetails.browser === 'safari' &&
+			Janus.webRTCAdapter.browserDetails.version >= 605) {
+			// Let's see if RTCRtpSender.getCapabilities() is there
+			if(RTCRtpSender && RTCRtpSender.getCapabilities && RTCRtpSender.getCapabilities("video") &&
+				RTCRtpSender.getCapabilities("video").codecs && RTCRtpSender.getCapabilities("video").codecs.length) {
+				for(var codec of RTCRtpSender.getCapabilities("video").codecs) {
+					if(codec && codec.mimeType && codec.mimeType.toLowerCase() === "video/vp8") {
+						Janus.safariVp8 = true;
+						break;
+					}
+				}
+				if(Janus.safariVp8) {
+					Janus.log("This version of Safari supports VP8");
+				} else {
+					Janus.warn("This version of Safari does NOT support VP8: if you're using a Technology Preview, " +
+						"try enabling the 'WebRTC VP8 codec' setting in the 'Experimental Features' Develop menu");
+				}
+			} else {
+				// We do it in a very ugly way, as there's no alternative...
+				// We create a PeerConnection to see if VP8 is in an offer
+				var testpc = new RTCPeerConnection({}, {});
+				testpc.createOffer({offerToReceiveVideo: true}).then(function(offer) {
+					Janus.safariVp8 = offer.sdp.indexOf("VP8") !== -1;
+					if(Janus.safariVp8) {
+						Janus.log("This version of Safari supports VP8");
+					} else {
+						Janus.warn("This version of Safari does NOT support VP8: if you're using a Technology Preview, " +
+							"try enabling the 'WebRTC VP8 codec' setting in the 'Experimental Features' Develop menu");
+					}
+					testpc.close();
+					testpc = null;
+				});
+			}
+		}
+		// Check if this browser supports Unified Plan and transceivers
+		// Based on https://codepen.io/anon/pen/ZqLwWV?editors=0010
+		Janus.unifiedPlan = false;
+		if(Janus.webRTCAdapter.browserDetails.browser === 'firefox' &&
+			Janus.webRTCAdapter.browserDetails.version >= 59) {
+			// Firefox definitely does, starting from version 59
+			Janus.unifiedPlan = true;
+		} else if(Janus.webRTCAdapter.browserDetails.browser === 'chrome' &&
+			Janus.webRTCAdapter.browserDetails.version < 72) {
+			// Chrome does, but it's only usable from version 72 on
+			Janus.unifiedPlan = false;
+		} else if(!window.RTCRtpTransceiver || !('currentDirection' in RTCRtpTransceiver.prototype)) {
+			// Safari supports addTransceiver() but not Unified Plan when
+			// currentDirection is not defined (see codepen above).
+			Janus.unifiedPlan = false;
+		} else {
+			// Check if addTransceiver() throws an exception
+			const tempPc = new RTCPeerConnection();
+			try {
+				tempPc.addTransceiver('audio');
+				Janus.unifiedPlan = true;
+			} catch (e) {}
+			tempPc.close();
+		}
+		Janus.initDone = true;
+		options.callback();
+	}
+};
+
+// Helper method to check whether WebRTC is supported by this browser
+Janus.isWebrtcSupported = function() {
+	return window.RTCPeerConnection ? true : false;
+};
+// Helper method to check whether devices can be accessed by this browser (e.g., not possible via plain HTTP)
+Janus.isGetUserMediaAvailable = function() {
+	return (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) ? true : false;
+};
+
+// Helper method to create random identifiers (e.g., transaction)
+Janus.randomString = function(len) {
+	var charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+	var randomString = '';
+	for (var i = 0; i < len; i++) {
+		var randomPoz = Math.floor(Math.random() * charSet.length);
+		randomString += charSet.substring(randomPoz,randomPoz+1);
+	}
+	return randomString;
+}
+
+
+function Janus(gatewayCallbacks) {
+	gatewayCallbacks = gatewayCallbacks || {};
+	gatewayCallbacks.success = (typeof gatewayCallbacks.success == "function") ? gatewayCallbacks.success : Janus.noop;
+	gatewayCallbacks.error = (typeof gatewayCallbacks.error == "function") ? gatewayCallbacks.error : Janus.noop;
+	gatewayCallbacks.destroyed = (typeof gatewayCallbacks.destroyed == "function") ? gatewayCallbacks.destroyed : Janus.noop;
+	if(!Janus.initDone) {
+		gatewayCallbacks.error("Library not initialized");
+		return {};
+	}
+	if(!Janus.isWebrtcSupported()) {
+		gatewayCallbacks.error("WebRTC not supported by this browser");
+		return {};
+	}
+	Janus.log("Library initialized: " + Janus.initDone);
+	if(!gatewayCallbacks.server) {
+		gatewayCallbacks.error("Invalid server url");
+		return {};
+	}
+	var websockets = false;
+	var ws = null;
+	var wsHandlers = {};
+	var wsKeepaliveTimeoutId = null;
+
+	var servers = null, serversIndex = 0;
+	var server = gatewayCallbacks.server;
+	if(Janus.isArray(server)) {
+		Janus.log("Multiple servers provided (" + server.length + "), will use the first that works");
+		server = null;
+		servers = gatewayCallbacks.server;
+		Janus.debug(servers);
+	} else {
+		if(server.indexOf("ws") === 0) {
+			websockets = true;
+			Janus.log("Using WebSockets to contact Janus: " + server);
+		} else {
+			websockets = false;
+			Janus.log("Using REST API to contact Janus: " + server);
+		}
+	}
+	var iceServers = gatewayCallbacks.iceServers || [{urls: "stun:stun.l.google.com:19302"}];
+	var iceTransportPolicy = gatewayCallbacks.iceTransportPolicy;
+	var bundlePolicy = gatewayCallbacks.bundlePolicy;
+	// Whether IPv6 candidates should be gathered
+	var ipv6Support = (gatewayCallbacks.ipv6 === true);
+	// Whether we should enable the withCredentials flag for XHR requests
+	var withCredentials = false;
+	if(gatewayCallbacks.withCredentials !== undefined && gatewayCallbacks.withCredentials !== null)
+		withCredentials = gatewayCallbacks.withCredentials === true;
+	// Optional max events
+	var maxev = 10;
+	if(gatewayCallbacks.max_poll_events !== undefined && gatewayCallbacks.max_poll_events !== null)
+		maxev = gatewayCallbacks.max_poll_events;
+	if(maxev < 1)
+		maxev = 1;
+	// Token to use (only if the token based authentication mechanism is enabled)
+	var token = null;
+	if(gatewayCallbacks.token !== undefined && gatewayCallbacks.token !== null)
+		token = gatewayCallbacks.token;
+	// API secret to use (only if the shared API secret is enabled)
+	var apisecret = null;
+	if(gatewayCallbacks.apisecret !== undefined && gatewayCallbacks.apisecret !== null)
+		apisecret = gatewayCallbacks.apisecret;
+	// Whether we should destroy this session when onbeforeunload is called
+	this.destroyOnUnload = true;
+	if(gatewayCallbacks.destroyOnUnload !== undefined && gatewayCallbacks.destroyOnUnload !== null)
+		this.destroyOnUnload = (gatewayCallbacks.destroyOnUnload === true);
+	// Some timeout-related values
+	var keepAlivePeriod = 25000;
+	if(gatewayCallbacks.keepAlivePeriod !== undefined && gatewayCallbacks.keepAlivePeriod !== null)
+		keepAlivePeriod = gatewayCallbacks.keepAlivePeriod;
+	if(isNaN(keepAlivePeriod))
+		keepAlivePeriod = 25000;
+	var longPollTimeout = 60000;
+	if(gatewayCallbacks.longPollTimeout !== undefined && gatewayCallbacks.longPollTimeout !== null)
+		longPollTimeout = gatewayCallbacks.longPollTimeout;
+	if(isNaN(longPollTimeout))
+		longPollTimeout = 60000;
+
+	// overrides for default maxBitrate values for simulcasting
+	function getMaxBitrates(simulcastMaxBitrates) {
+		var maxBitrates = {
+			high: 900000,
+			medium: 300000,
+			low: 100000,
+		};
+
+		if (simulcastMaxBitrates !== undefined && simulcastMaxBitrates !== null) {
+			if (simulcastMaxBitrates.high)
+				maxBitrates.high = simulcastMaxBitrates.high;
+			if (simulcastMaxBitrates.medium)
+				maxBitrates.medium = simulcastMaxBitrates.medium;
+			if (simulcastMaxBitrates.low)
+				maxBitrates.low = simulcastMaxBitrates.low;
+		}
+
+		return maxBitrates;
+	}
+
+	var connected = false;
+	var sessionId = null;
+	var pluginHandles = {};
+	var that = this;
+	var retries = 0;
+	var transactions = {};
+	createSession(gatewayCallbacks);
+
+	// Public methods
+	this.getServer = function() { return server; };
+	this.isConnected = function() { return connected; };
+	this.reconnect = function(callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		callbacks["reconnect"] = true;
+		createSession(callbacks);
+	};
+	this.getSessionId = function() { return sessionId; };
+	this.destroy = function(callbacks) { destroySession(callbacks); };
+	this.attach = function(callbacks) { createHandle(callbacks); };
+
+	function eventHandler() {
+		if(sessionId == null)
+			return;
+		Janus.debug('Long poll...');
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			return;
+		}
+		var longpoll = server + "/" + sessionId + "?rid=" + new Date().getTime();
+		if(maxev)
+			longpoll = longpoll + "&maxev=" + maxev;
+		if(token)
+			longpoll = longpoll + "&token=" + encodeURIComponent(token);
+		if(apisecret)
+			longpoll = longpoll + "&apisecret=" + encodeURIComponent(apisecret);
+		Janus.httpAPICall(longpoll, {
+			verb: 'GET',
+			withCredentials: withCredentials,
+			success: handleEvent,
+			timeout: longPollTimeout,
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);
+				retries++;
+				if(retries > 3) {
+					// Did we just lose the server? :-(
+					connected = false;
+					gatewayCallbacks.error("Lost connection to the server (is it down?)");
+					return;
+				}
+				eventHandler();
+			}
+		});
+	}
+
+	// Private event handler: this will trigger plugin callbacks, if set
+	function handleEvent(json, skipTimeout) {
+		retries = 0;
+		if(!websockets && sessionId !== undefined && sessionId !== null && skipTimeout !== true)
+			eventHandler();
+		if(!websockets && Janus.isArray(json)) {
+			// We got an array: it means we passed a maxev > 1, iterate on all objects
+			for(var i=0; i<json.length; i++) {
+				handleEvent(json[i], true);
+			}
+			return;
+		}
+		if(json["janus"] === "keepalive") {
+			// Nothing happened
+			Janus.vdebug("Got a keepalive on session " + sessionId);
+			return;
+		} else if(json["janus"] === "ack") {
+			// Just an ack, we can probably ignore
+			Janus.debug("Got an ack on session " + sessionId);
+			Janus.debug(json);
+			var transaction = json["transaction"];
+			if(transaction) {
+				var reportSuccess = transactions[transaction];
+				if(reportSuccess)
+					reportSuccess(json);
+				delete transactions[transaction];
+			}
+			return;
+		} else if(json["janus"] === "success") {
+			// Success!
+			Janus.debug("Got a success on session " + sessionId);
+			Janus.debug(json);
+			var transaction = json["transaction"];
+			if(transaction) {
+				var reportSuccess = transactions[transaction];
+				if(reportSuccess)
+					reportSuccess(json);
+				delete transactions[transaction];
+			}
+			return;
+		} else if(json["janus"] === "trickle") {
+			// We got a trickle candidate from Janus
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.debug("This handle is not attached to this session");
+				return;
+			}
+			var candidate = json["candidate"];
+			Janus.debug("Got a trickled candidate on session " + sessionId);
+			Janus.debug(candidate);
+			var config = pluginHandle.webrtcStuff;
+			if(config.pc && config.remoteSdp) {
+				// Add candidate right now
+				Janus.debug("Adding remote candidate:", candidate);
+				if(!candidate || candidate.completed === true) {
+					// end-of-candidates
+					config.pc.addIceCandidate(Janus.endOfCandidates);
+				} else {
+					// New candidate
+					config.pc.addIceCandidate(candidate);
+				}
+			} else {
+				// We didn't do setRemoteDescription (trickle got here before the offer?)
+				Janus.debug("We didn't do setRemoteDescription (trickle got here before the offer?), caching candidate");
+				if(!config.candidates)
+					config.candidates = [];
+				config.candidates.push(candidate);
+				Janus.debug(config.candidates);
+			}
+		} else if(json["janus"] === "webrtcup") {
+			// The PeerConnection with the server is up! Notify this
+			Janus.debug("Got a webrtcup event on session " + sessionId);
+			Janus.debug(json);
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.debug("This handle is not attached to this session");
+				return;
+			}
+			pluginHandle.webrtcState(true);
+			return;
+		} else if(json["janus"] === "hangup") {
+			// A plugin asked the core to hangup a PeerConnection on one of our handles
+			Janus.debug("Got a hangup event on session " + sessionId);
+			Janus.debug(json);
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.debug("This handle is not attached to this session");
+				return;
+			}
+			pluginHandle.webrtcState(false, json["reason"]);
+			pluginHandle.hangup();
+		} else if(json["janus"] === "detached") {
+			// A plugin asked the core to detach one of our handles
+			Janus.debug("Got a detached event on session " + sessionId);
+			Janus.debug(json);
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				// Don't warn here because destroyHandle causes this situation.
+				return;
+			}
+			pluginHandle.detached = true;
+			pluginHandle.ondetached();
+			pluginHandle.detach();
+		} else if(json["janus"] === "media") {
+			// Media started/stopped flowing
+			Janus.debug("Got a media event on session " + sessionId);
+			Janus.debug(json);
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.debug("This handle is not attached to this session");
+				return;
+			}
+			pluginHandle.mediaState(json["type"], json["receiving"]);
+		} else if(json["janus"] === "slowlink") {
+			Janus.debug("Got a slowlink event on session " + sessionId);
+			Janus.debug(json);
+			// Trouble uplink or downlink
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.debug("This handle is not attached to this session");
+				return;
+			}
+			pluginHandle.slowLink(json["uplink"], json["lost"]);
+		} else if(json["janus"] === "error") {
+			// Oops, something wrong happened
+			Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+			Janus.debug(json);
+			var transaction = json["transaction"];
+			if(transaction) {
+				var reportSuccess = transactions[transaction];
+				if(reportSuccess) {
+					reportSuccess(json);
+				}
+				delete transactions[transaction];
+			}
+			return;
+		} else if(json["janus"] === "event") {
+			Janus.debug("Got a plugin event on session " + sessionId);
+			Janus.debug(json);
+			var sender = json["sender"];
+			if(!sender) {
+				Janus.warn("Missing sender...");
+				return;
+			}
+			var plugindata = json["plugindata"];
+			if(!plugindata) {
+				Janus.warn("Missing plugindata...");
+				return;
+			}
+			Janus.debug("  -- Event is coming from " + sender + " (" + plugindata["plugin"] + ")");
+			var data = plugindata["data"];
+			Janus.debug(data);
+			var pluginHandle = pluginHandles[sender];
+			if(!pluginHandle) {
+				Janus.warn("This handle is not attached to this session");
+				return;
+			}
+			var jsep = json["jsep"];
+			if(jsep) {
+				Janus.debug("Handling SDP as well...");
+				Janus.debug(jsep);
+			}
+			var callback = pluginHandle.onmessage;
+			if(callback) {
+				Janus.debug("Notifying application...");
+				// Send to callback specified when attaching plugin handle
+				callback(data, jsep);
+			} else {
+				// Send to generic callback (?)
+				Janus.debug("No provided notification callback");
+			}
+		} else if(json["janus"] === "timeout") {
+			Janus.error("Timeout on session " + sessionId);
+			Janus.debug(json);
+			if (websockets) {
+				ws.close(3504, "Gateway timeout");
+			}
+			return;
+		} else {
+			Janus.warn("Unknown message/event  '" + json["janus"] + "' on session " + sessionId);
+			Janus.debug(json);
+		}
+	}
+
+	// Private helper to send keep-alive messages on WebSockets
+	function keepAlive() {
+		if(!server || !websockets || !connected)
+			return;
+		wsKeepaliveTimeoutId = setTimeout(keepAlive, keepAlivePeriod);
+		var request = { "janus": "keepalive", "session_id": sessionId, "transaction": Janus.randomString(12) };
+		if(token)
+			request["token"] = token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		ws.send(JSON.stringify(request));
+	}
+
+	// Private method to create a session
+	function createSession(callbacks) {
+		var transaction = Janus.randomString(12);
+		var request = { "janus": "create", "transaction": transaction };
+		if(callbacks["reconnect"]) {
+			// We're reconnecting, claim the session
+			connected = false;
+			request["janus"] = "claim";
+			request["session_id"] = sessionId;
+			// If we were using websockets, ignore the old connection
+			if(ws) {
+				ws.onopen = null;
+				ws.onerror = null;
+				ws.onclose = null;
+				if(wsKeepaliveTimeoutId) {
+					clearTimeout(wsKeepaliveTimeoutId);
+					wsKeepaliveTimeoutId = null;
+				}
+			}
+		}
+		if(token)
+			request["token"] = token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		if(!server && Janus.isArray(servers)) {
+			// We still need to find a working server from the list we were given
+			server = servers[serversIndex];
+			if(server.indexOf("ws") === 0) {
+				websockets = true;
+				Janus.log("Server #" + (serversIndex+1) + ": trying WebSockets to contact Janus (" + server + ")");
+			} else {
+				websockets = false;
+				Janus.log("Server #" + (serversIndex+1) + ": trying REST API to contact Janus (" + server + ")");
+			}
+		}
+		if(websockets) {
+			ws = Janus.newWebSocket(server, 'janus-protocol');
+			wsHandlers = {
+				'error': function() {
+					Janus.error("Error connecting to the Janus WebSockets server... " + server);
+					if (Janus.isArray(servers) && !callbacks["reconnect"]) {
+						serversIndex++;
+						if (serversIndex == servers.length) {
+							// We tried all the servers the user gave us and they all failed
+							callbacks.error("Error connecting to any of the provided Janus servers: Is the server down?");
+							return;
+						}
+						// Let's try the next server
+						server = null;
+						setTimeout(function() {
+							createSession(callbacks);
+						}, 200);
+						return;
+					}
+					callbacks.error("Error connecting to the Janus WebSockets server: Is the server down?");
+				},
+
+				'open': function() {
+					// We need to be notified about the success
+					transactions[transaction] = function(json) {
+						Janus.debug(json);
+						if (json["janus"] !== "success") {
+							Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+							callbacks.error(json["error"].reason);
+							return;
+						}
+						wsKeepaliveTimeoutId = setTimeout(keepAlive, keepAlivePeriod);
+						connected = true;
+						sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+						if(callbacks["reconnect"]) {
+							Janus.log("Claimed session: " + sessionId);
+						} else {
+							Janus.log("Created session: " + sessionId);
+						}
+						Janus.sessions[sessionId] = that;
+						callbacks.success();
+					};
+					ws.send(JSON.stringify(request));
+				},
+
+				'message': function(event) {
+					handleEvent(JSON.parse(event.data));
+				},
+
+				'close': function() {
+					if (!server || !connected) {
+						return;
+					}
+					connected = false;
+					// FIXME What if this is called when the page is closed?
+					gatewayCallbacks.error("Lost connection to the server (is it down?)");
+				}
+			};
+
+			for(var eventName in wsHandlers) {
+				ws.addEventListener(eventName, wsHandlers[eventName]);
+			}
+
+			return;
+		}
+		Janus.httpAPICall(server, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.debug(json);
+				if(json["janus"] !== "success") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+					callbacks.error(json["error"].reason);
+					return;
+				}
+				connected = true;
+				sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+				if(callbacks["reconnect"]) {
+					Janus.log("Claimed session: " + sessionId);
+				} else {
+					Janus.log("Created session: " + sessionId);
+				}
+				Janus.sessions[sessionId] = that;
+				eventHandler();
+				callbacks.success();
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+				if(Janus.isArray(servers) && !callbacks["reconnect"]) {
+					serversIndex++;
+					if(serversIndex == servers.length) {
+						// We tried all the servers the user gave us and they all failed
+						callbacks.error("Error connecting to any of the provided Janus servers: Is the server down?");
+						return;
+					}
+					// Let's try the next server
+					server = null;
+					setTimeout(function() { createSession(callbacks); }, 200);
+					return;
+				}
+				if(errorThrown === "")
+					callbacks.error(textStatus + ": Is the server down?");
+				else
+					callbacks.error(textStatus + ": " + errorThrown);
+			}
+		});
+	}
+
+	// Private method to destroy a session
+	function destroySession(callbacks) {
+		callbacks = callbacks || {};
+		// FIXME This method triggers a success even when we fail
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		var unload = (callbacks.unload === true);
+		var notifyDestroyed = true;
+		if(callbacks.notifyDestroyed !== undefined && callbacks.notifyDestroyed !== null)
+			notifyDestroyed = (callbacks.notifyDestroyed === true);
+		var cleanupHandles = (callbacks.cleanupHandles === true);
+		Janus.log("Destroying session " + sessionId + " (unload=" + unload + ")");
+		if(!sessionId) {
+			Janus.warn("No session to destroy");
+			callbacks.success();
+			if(notifyDestroyed)
+				gatewayCallbacks.destroyed();
+			return;
+		}
+		if(cleanupHandles) {
+			for(var handleId in pluginHandles)
+				destroyHandle(handleId, { noRequest: true });
+		}
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			sessionId = null;
+			callbacks.success();
+			return;
+		}
+		// No need to destroy all handles first, Janus will do that itself
+		var request = { "janus": "destroy", "transaction": Janus.randomString(12) };
+		if(token)
+			request["token"] = token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		if(unload) {
+			// We're unloading the page: use sendBeacon for HTTP instead,
+			// or just close the WebSocket connection if we're using that
+			if(websockets) {
+				ws.onclose = null;
+				ws.close();
+				ws = null;
+			} else {
+				navigator.sendBeacon(server + "/" + sessionId, JSON.stringify(request));
+			}
+			Janus.log("Destroyed session:");
+			sessionId = null;
+			connected = false;
+			callbacks.success();
+			if(notifyDestroyed)
+				gatewayCallbacks.destroyed();
+			return;
+		}
+		if(websockets) {
+			request["session_id"] = sessionId;
+
+			var unbindWebSocket = function() {
+				for(var eventName in wsHandlers) {
+					ws.removeEventListener(eventName, wsHandlers[eventName]);
+				}
+				ws.removeEventListener('message', onUnbindMessage);
+				ws.removeEventListener('error', onUnbindError);
+				if(wsKeepaliveTimeoutId) {
+					clearTimeout(wsKeepaliveTimeoutId);
+				}
+				ws.close();
+			};
+
+			var onUnbindMessage = function(event){
+				var data = JSON.parse(event.data);
+				if(data.session_id == request.session_id && data.transaction == request.transaction) {
+					unbindWebSocket();
+					callbacks.success();
+					if(notifyDestroyed)
+						gatewayCallbacks.destroyed();
+				}
+			};
+			var onUnbindError = function(event) {
+				unbindWebSocket();
+				callbacks.error("Failed to destroy the server: Is the server down?");
+				if(notifyDestroyed)
+					gatewayCallbacks.destroyed();
+			};
+
+			ws.addEventListener('message', onUnbindMessage);
+			ws.addEventListener('error', onUnbindError);
+
+			ws.send(JSON.stringify(request));
+			return;
+		}
+		Janus.httpAPICall(server + "/" + sessionId, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.log("Destroyed session:");
+				Janus.debug(json);
+				sessionId = null;
+				connected = false;
+				if(json["janus"] !== "success") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+				}
+				callbacks.success();
+				if(notifyDestroyed)
+					gatewayCallbacks.destroyed();
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+				// Reset everything anyway
+				sessionId = null;
+				connected = false;
+				callbacks.success();
+				if(notifyDestroyed)
+					gatewayCallbacks.destroyed();
+			}
+		});
+	}
+
+	// Private method to create a plugin handle
+	function createHandle(callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		callbacks.consentDialog = (typeof callbacks.consentDialog == "function") ? callbacks.consentDialog : Janus.noop;
+		callbacks.iceState = (typeof callbacks.iceState == "function") ? callbacks.iceState : Janus.noop;
+		callbacks.mediaState = (typeof callbacks.mediaState == "function") ? callbacks.mediaState : Janus.noop;
+		callbacks.webrtcState = (typeof callbacks.webrtcState == "function") ? callbacks.webrtcState : Janus.noop;
+		callbacks.slowLink = (typeof callbacks.slowLink == "function") ? callbacks.slowLink : Janus.noop;
+		callbacks.onmessage = (typeof callbacks.onmessage == "function") ? callbacks.onmessage : Janus.noop;
+		callbacks.onlocalstream = (typeof callbacks.onlocalstream == "function") ? callbacks.onlocalstream : Janus.noop;
+		callbacks.onremotestream = (typeof callbacks.onremotestream == "function") ? callbacks.onremotestream : Janus.noop;
+		callbacks.ondata = (typeof callbacks.ondata == "function") ? callbacks.ondata : Janus.noop;
+		callbacks.ondataopen = (typeof callbacks.ondataopen == "function") ? callbacks.ondataopen : Janus.noop;
+		callbacks.oncleanup = (typeof callbacks.oncleanup == "function") ? callbacks.oncleanup : Janus.noop;
+		callbacks.ondetached = (typeof callbacks.ondetached == "function") ? callbacks.ondetached : Janus.noop;
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			callbacks.error("Is the server down? (connected=false)");
+			return;
+		}
+		var plugin = callbacks.plugin;
+		if(!plugin) {
+			Janus.error("Invalid plugin");
+			callbacks.error("Invalid plugin");
+			return;
+		}
+		var opaqueId = callbacks.opaqueId;
+		var handleToken = callbacks.token ? callbacks.token : token;
+		var transaction = Janus.randomString(12);
+		var request = { "janus": "attach", "plugin": plugin, "opaque_id": opaqueId, "transaction": transaction };
+		if(handleToken)
+			request["token"] = handleToken;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		if(websockets) {
+			transactions[transaction] = function(json) {
+				Janus.debug(json);
+				if(json["janus"] !== "success") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+					callbacks.error("Ooops: " + json["error"].code + " " + json["error"].reason);
+					return;
+				}
+				var handleId = json.data["id"];
+				Janus.log("Created handle: " + handleId);
+				var pluginHandle =
+					{
+						session : that,
+						plugin : plugin,
+						id : handleId,
+						token : handleToken,
+						detached : false,
+						webrtcStuff : {
+							started : false,
+							myStream : null,
+							streamExternal : false,
+							remoteStream : null,
+							mySdp : null,
+							mediaConstraints : null,
+							pc : null,
+							dataChannel : {},
+							dtmfSender : null,
+							trickle : true,
+							iceDone : false,
+							volume : {
+								value : null,
+								timer : null
+							},
+							bitrate : {
+								value : null,
+								bsnow : null,
+								bsbefore : null,
+								tsnow : null,
+								tsbefore : null,
+								timer : null
+							}
+						},
+						getId : function() { return handleId; },
+						getPlugin : function() { return plugin; },
+						getVolume : function() { return getVolume(handleId, true); },
+						getRemoteVolume : function() { return getVolume(handleId, true); },
+						getLocalVolume : function() { return getVolume(handleId, false); },
+						isAudioMuted : function() { return isMuted(handleId, false); },
+						muteAudio : function() { return mute(handleId, false, true); },
+						unmuteAudio : function() { return mute(handleId, false, false); },
+						isVideoMuted : function() { return isMuted(handleId, true); },
+						muteVideo : function() { return mute(handleId, true, true); },
+						unmuteVideo : function() { return mute(handleId, true, false); },
+						getBitrate : function() { return getBitrate(handleId); },
+						send : function(callbacks) { sendMessage(handleId, callbacks); },
+						data : function(callbacks) { sendData(handleId, callbacks); },
+						dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
+						consentDialog : callbacks.consentDialog,
+						iceState : callbacks.iceState,
+						mediaState : callbacks.mediaState,
+						webrtcState : callbacks.webrtcState,
+						slowLink : callbacks.slowLink,
+						onmessage : callbacks.onmessage,
+						createOffer : function(callbacks) { prepareWebrtc(handleId, true, callbacks); },
+						createAnswer : function(callbacks) { prepareWebrtc(handleId, false, callbacks); },
+						handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
+						onlocalstream : callbacks.onlocalstream,
+						onremotestream : callbacks.onremotestream,
+						ondata : callbacks.ondata,
+						ondataopen : callbacks.ondataopen,
+						oncleanup : callbacks.oncleanup,
+						ondetached : callbacks.ondetached,
+						hangup : function(sendRequest) { cleanupWebrtc(handleId, sendRequest === true); },
+						detach : function(callbacks) { destroyHandle(handleId, callbacks); }
+					}
+				pluginHandles[handleId] = pluginHandle;
+				callbacks.success(pluginHandle);
+			};
+			request["session_id"] = sessionId;
+			ws.send(JSON.stringify(request));
+			return;
+		}
+		Janus.httpAPICall(server + "/" + sessionId, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.debug(json);
+				if(json["janus"] !== "success") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+					callbacks.error("Ooops: " + json["error"].code + " " + json["error"].reason);
+					return;
+				}
+				var handleId = json.data["id"];
+				Janus.log("Created handle: " + handleId);
+				var pluginHandle =
+					{
+						session : that,
+						plugin : plugin,
+						id : handleId,
+						token : handleToken,
+						detached : false,
+						webrtcStuff : {
+							started : false,
+							myStream : null,
+							streamExternal : false,
+							remoteStream : null,
+							mySdp : null,
+							mediaConstraints : null,
+							pc : null,
+							dataChannel : {},
+							dtmfSender : null,
+							trickle : true,
+							iceDone : false,
+							volume : {
+								value : null,
+								timer : null
+							},
+							bitrate : {
+								value : null,
+								bsnow : null,
+								bsbefore : null,
+								tsnow : null,
+								tsbefore : null,
+								timer : null
+							}
+						},
+						getId : function() { return handleId; },
+						getPlugin : function() { return plugin; },
+						getVolume : function() { return getVolume(handleId, true); },
+						getRemoteVolume : function() { return getVolume(handleId, true); },
+						getLocalVolume : function() { return getVolume(handleId, false); },
+						isAudioMuted : function() { return isMuted(handleId, false); },
+						muteAudio : function() { return mute(handleId, false, true); },
+						unmuteAudio : function() { return mute(handleId, false, false); },
+						isVideoMuted : function() { return isMuted(handleId, true); },
+						muteVideo : function() { return mute(handleId, true, true); },
+						unmuteVideo : function() { return mute(handleId, true, false); },
+						getBitrate : function() { return getBitrate(handleId); },
+						send : function(callbacks) { sendMessage(handleId, callbacks); },
+						data : function(callbacks) { sendData(handleId, callbacks); },
+						dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
+						consentDialog : callbacks.consentDialog,
+						iceState : callbacks.iceState,
+						mediaState : callbacks.mediaState,
+						webrtcState : callbacks.webrtcState,
+						slowLink : callbacks.slowLink,
+						onmessage : callbacks.onmessage,
+						createOffer : function(callbacks) { prepareWebrtc(handleId, true, callbacks); },
+						createAnswer : function(callbacks) { prepareWebrtc(handleId, false, callbacks); },
+						handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
+						onlocalstream : callbacks.onlocalstream,
+						onremotestream : callbacks.onremotestream,
+						ondata : callbacks.ondata,
+						ondataopen : callbacks.ondataopen,
+						oncleanup : callbacks.oncleanup,
+						ondetached : callbacks.ondetached,
+						hangup : function(sendRequest) { cleanupWebrtc(handleId, sendRequest === true); },
+						detach : function(callbacks) { destroyHandle(handleId, callbacks); }
+					}
+				pluginHandles[handleId] = pluginHandle;
+				callbacks.success(pluginHandle);
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+				if(errorThrown === "")
+					callbacks.error(textStatus + ": Is the server down?");
+				else
+					callbacks.error(textStatus + ": " + errorThrown);
+			}
+		});
+	}
+
+	// Private method to send a message
+	function sendMessage(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			callbacks.error("Is the server down? (connected=false)");
+			return;
+		}
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var message = callbacks.message;
+		var jsep = callbacks.jsep;
+		var transaction = Janus.randomString(12);
+		var request = { "janus": "message", "body": message, "transaction": transaction };
+		if(pluginHandle.token)
+			request["token"] = pluginHandle.token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		if(jsep)
+			request.jsep = jsep;
+		Janus.debug("Sending message to plugin (handle=" + handleId + "):");
+		Janus.debug(request);
+		if(websockets) {
+			request["session_id"] = sessionId;
+			request["handle_id"] = handleId;
+			transactions[transaction] = function(json) {
+				Janus.debug("Message sent!");
+				Janus.debug(json);
+				if(json["janus"] === "success") {
+					// We got a success, must have been a synchronous transaction
+					var plugindata = json["plugindata"];
+					if(!plugindata) {
+						Janus.warn("Request succeeded, but missing plugindata...");
+						callbacks.success();
+						return;
+					}
+					Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
+					var data = plugindata["data"];
+					Janus.debug(data);
+					callbacks.success(data);
+					return;
+				} else if(json["janus"] !== "ack") {
+					// Not a success and not an ack, must be an error
+					if(json["error"]) {
+						Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+						callbacks.error(json["error"].code + " " + json["error"].reason);
+					} else {
+						Janus.error("Unknown error");	// FIXME
+						callbacks.error("Unknown error");
+					}
+					return;
+				}
+				// If we got here, the plugin decided to handle the request asynchronously
+				callbacks.success();
+			};
+			ws.send(JSON.stringify(request));
+			return;
+		}
+		Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.debug("Message sent!");
+				Janus.debug(json);
+				if(json["janus"] === "success") {
+					// We got a success, must have been a synchronous transaction
+					var plugindata = json["plugindata"];
+					if(!plugindata) {
+						Janus.warn("Request succeeded, but missing plugindata...");
+						callbacks.success();
+						return;
+					}
+					Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
+					var data = plugindata["data"];
+					Janus.debug(data);
+					callbacks.success(data);
+					return;
+				} else if(json["janus"] !== "ack") {
+					// Not a success and not an ack, must be an error
+					if(json["error"]) {
+						Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+						callbacks.error(json["error"].code + " " + json["error"].reason);
+					} else {
+						Janus.error("Unknown error");	// FIXME
+						callbacks.error("Unknown error");
+					}
+					return;
+				}
+				// If we got here, the plugin decided to handle the request asynchronously
+				callbacks.success();
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+				callbacks.error(textStatus + ": " + errorThrown);
+			}
+		});
+	}
+
+	// Private method to send a trickle candidate
+	function sendTrickleCandidate(handleId, candidate) {
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			return;
+		}
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return;
+		}
+		var request = { "janus": "trickle", "candidate": candidate, "transaction": Janus.randomString(12) };
+		if(pluginHandle.token)
+			request["token"] = pluginHandle.token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		Janus.vdebug("Sending trickle candidate (handle=" + handleId + "):");
+		Janus.vdebug(request);
+		if(websockets) {
+			request["session_id"] = sessionId;
+			request["handle_id"] = handleId;
+			ws.send(JSON.stringify(request));
+			return;
+		}
+		Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.vdebug("Candidate sent!");
+				Janus.vdebug(json);
+				if(json["janus"] !== "ack") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+					return;
+				}
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+			}
+		});
+	}
+
+	// Private method to create a data channel
+	function createDataChannel(handleId, dclabel, incoming, pendingData) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		var onDataChannelMessage = function(event) {
+			Janus.log('Received message on data channel:', event);
+			var label = event.target.label;
+			pluginHandle.ondata(event.data, label);
+		}
+		var onDataChannelStateChange = function(event) {
+			Janus.log('Received state change on data channel:', event);
+			var label = event.target.label;
+			var dcState = config.dataChannel[label] ? config.dataChannel[label].readyState : "null";
+			Janus.log('State change on <' + label + '> data channel: ' + dcState);
+			if(dcState === 'open') {
+				// Any pending messages to send?
+				if(config.dataChannel[label].pending && config.dataChannel[label].pending.length > 0) {
+					Janus.log("Sending pending messages on <" + label + ">:", config.dataChannel[label].pending.length);
+					for(var data of config.dataChannel[label].pending) {
+						Janus.log("Sending data on data channel <" + label + ">");
+						Janus.debug(data);
+						config.dataChannel[label].send(data);
+					}
+					config.dataChannel[label].pending = [];
+				}
+				// Notify the open data channel
+				pluginHandle.ondataopen(label);
+			}
+		}
+		var onDataChannelError = function(error) {
+			Janus.error('Got error on data channel:', error);
+			// TODO
+		}
+		if(!incoming) {
+			// FIXME Add options (ordered, maxRetransmits, etc.)
+			config.dataChannel[dclabel] = config.pc.createDataChannel(dclabel, {ordered: true});
+		} else {
+			// The channel was created by Janus
+			config.dataChannel[dclabel] = incoming;
+		}
+		config.dataChannel[dclabel].onmessage = onDataChannelMessage;
+		config.dataChannel[dclabel].onopen = onDataChannelStateChange;
+		config.dataChannel[dclabel].onclose = onDataChannelStateChange;
+		config.dataChannel[dclabel].onerror = onDataChannelError;
+		config.dataChannel[dclabel].pending = [];
+		if(pendingData)
+			config.dataChannel[dclabel].pending.push(pendingData);
+	}
+
+	// Private method to send a data channel message
+	function sendData(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		var data = callbacks.text || callbacks.data;
+		if(!data) {
+			Janus.warn("Invalid data");
+			callbacks.error("Invalid data");
+			return;
+		}
+		var label = callbacks.label ? callbacks.label : Janus.dataChanDefaultLabel;
+		if(!config.dataChannel[label]) {
+			// Create new data channel and wait for it to open
+			createDataChannel(handleId, label, false, data);
+			callbacks.success();
+			return;
+		}
+		if(config.dataChannel[label].readyState !== "open") {
+			config.dataChannel[label].pending.push(data);
+			callbacks.success();
+			return;
+		}
+		Janus.log("Sending data on data channel <" + label + ">");
+		Janus.debug(data);
+		config.dataChannel[label].send(data);
+		callbacks.success();
+	}
+
+	// Private method to send a DTMF tone
+	function sendDtmf(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(!config.dtmfSender) {
+			// Create the DTMF sender the proper way, if possible
+			if(config.pc) {
+				var senders = config.pc.getSenders();
+				var audioSender = senders.find(function(sender) {
+					return sender.track && sender.track.kind === 'audio';
+				});
+				if(!audioSender) {
+					Janus.warn("Invalid DTMF configuration (no audio track)");
+					callbacks.error("Invalid DTMF configuration (no audio track)");
+					return;
+				}
+				config.dtmfSender = audioSender.dtmf;
+				if(config.dtmfSender) {
+					Janus.log("Created DTMF Sender");
+					config.dtmfSender.ontonechange = function(tone) { Janus.debug("Sent DTMF tone: " + tone.tone); };
+				}
+			}
+			if(!config.dtmfSender) {
+				Janus.warn("Invalid DTMF configuration");
+				callbacks.error("Invalid DTMF configuration");
+				return;
+			}
+		}
+		var dtmf = callbacks.dtmf;
+		if(!dtmf) {
+			Janus.warn("Invalid DTMF parameters");
+			callbacks.error("Invalid DTMF parameters");
+			return;
+		}
+		var tones = dtmf.tones;
+		if(!tones) {
+			Janus.warn("Invalid DTMF string");
+			callbacks.error("Invalid DTMF string");
+			return;
+		}
+		var duration = (typeof dtmf.duration === 'number') ? dtmf.duration : 500; // We choose 500ms as the default duration for a tone
+		var gap = (typeof dtmf.gap === 'number') ? dtmf.gap : 50; // We choose 50ms as the default gap between tones
+		Janus.debug("Sending DTMF string " + tones + " (duration " + duration + "ms, gap " + gap + "ms)");
+		config.dtmfSender.insertDTMF(tones, duration, gap);
+		callbacks.success();
+	}
+
+	// Private method to destroy a plugin handle
+	function destroyHandle(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		var noRequest = (callbacks.noRequest === true);
+		Janus.log("Destroying handle " + handleId + " (only-locally=" + noRequest + ")");
+		cleanupWebrtc(handleId);
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || pluginHandle.detached) {
+			// Plugin was already detached by Janus, calling detach again will return a handle not found error, so just exit here
+			delete pluginHandles[handleId];
+			callbacks.success();
+			return;
+		}
+		if(noRequest) {
+			// We're only removing the handle locally
+			delete pluginHandles[handleId];
+			callbacks.success();
+			return;
+		}
+		if(!connected) {
+			Janus.warn("Is the server down? (connected=false)");
+			callbacks.error("Is the server down? (connected=false)");
+			return;
+		}
+		var request = { "janus": "detach", "transaction": Janus.randomString(12) };
+		if(pluginHandle.token)
+			request["token"] = pluginHandle.token;
+		if(apisecret)
+			request["apisecret"] = apisecret;
+		if(websockets) {
+			request["session_id"] = sessionId;
+			request["handle_id"] = handleId;
+			ws.send(JSON.stringify(request));
+			delete pluginHandles[handleId];
+			callbacks.success();
+			return;
+		}
+		Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
+			verb: 'POST',
+			withCredentials: withCredentials,
+			body: request,
+			success: function(json) {
+				Janus.log("Destroyed handle:");
+				Janus.debug(json);
+				if(json["janus"] !== "success") {
+					Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason);	// FIXME
+				}
+				delete pluginHandles[handleId];
+				callbacks.success();
+			},
+			error: function(textStatus, errorThrown) {
+				Janus.error(textStatus + ":", errorThrown);	// FIXME
+				// We cleanup anyway
+				delete pluginHandles[handleId];
+				callbacks.success();
+			}
+		});
+	}
+
+	// WebRTC stuff
+	function streamsDone(handleId, jsep, media, callbacks, stream) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		Janus.debug("streamsDone:", stream);
+		if(stream) {
+			Janus.debug("  -- Audio tracks:", stream.getAudioTracks());
+			Janus.debug("  -- Video tracks:", stream.getVideoTracks());
+		}
+		// We're now capturing the new stream: check if we're updating or if it's a new thing
+		var addTracks = false;
+		if(!config.myStream || !media.update || config.streamExternal) {
+			config.myStream = stream;
+			addTracks = true;
+		} else {
+			// We only need to update the existing stream
+			if(((!media.update && isAudioSendEnabled(media)) || (media.update && (media.addAudio || media.replaceAudio))) &&
+				stream.getAudioTracks() && stream.getAudioTracks().length) {
+				config.myStream.addTrack(stream.getAudioTracks()[0]);
+				if(Janus.unifiedPlan) {
+					// Use Transceivers
+					Janus.log((media.replaceAudio ? "Replacing" : "Adding") + " audio track:", stream.getAudioTracks()[0]);
+					var audioTransceiver = null;
+					var transceivers = config.pc.getTransceivers();
+					if(transceivers && transceivers.length > 0) {
+						for(var t of transceivers) {
+							if((t.sender && t.sender.track && t.sender.track.kind === "audio") ||
+								(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")) {
+								audioTransceiver = t;
+								break;
+							}
+						}
+					}
+					if(audioTransceiver && audioTransceiver.sender) {
+						audioTransceiver.sender.replaceTrack(stream.getAudioTracks()[0]);
+					} else {
+						config.pc.addTrack(stream.getAudioTracks()[0], stream);
+					}
+				} else {
+					Janus.log((media.replaceAudio ? "Replacing" : "Adding") + " audio track:", stream.getAudioTracks()[0]);
+					config.pc.addTrack(stream.getAudioTracks()[0], stream);
+				}
+			}
+			if(((!media.update && isVideoSendEnabled(media)) || (media.update && (media.addVideo || media.replaceVideo))) &&
+				stream.getVideoTracks() && stream.getVideoTracks().length) {
+				config.myStream.addTrack(stream.getVideoTracks()[0]);
+				if(Janus.unifiedPlan) {
+					// Use Transceivers
+					Janus.log((media.replaceVideo ? "Replacing" : "Adding") + " video track:", stream.getVideoTracks()[0]);
+					var videoTransceiver = null;
+					var transceivers = config.pc.getTransceivers();
+					if(transceivers && transceivers.length > 0) {
+						for(var t of transceivers) {
+							if((t.sender && t.sender.track && t.sender.track.kind === "video") ||
+								(t.receiver && t.receiver.track && t.receiver.track.kind === "video")) {
+								videoTransceiver = t;
+								break;
+							}
+						}
+					}
+					if(videoTransceiver && videoTransceiver.sender) {
+						videoTransceiver.sender.replaceTrack(stream.getVideoTracks()[0]);
+					} else {
+						config.pc.addTrack(stream.getVideoTracks()[0], stream);
+					}
+				} else {
+					Janus.log((media.replaceVideo ? "Replacing" : "Adding") + " video track:", stream.getVideoTracks()[0]);
+					config.pc.addTrack(stream.getVideoTracks()[0], stream);
+				}
+			}
+		}
+		// If we still need to create a PeerConnection, let's do that
+		if(!config.pc) {
+			var pc_config = {"iceServers": iceServers, "iceTransportPolicy": iceTransportPolicy, "bundlePolicy": bundlePolicy};
+			if(Janus.webRTCAdapter.browserDetails.browser === "chrome") {
+				// For Chrome versions before 72, we force a plan-b semantic, and unified-plan otherwise
+				pc_config["sdpSemantics"] = (Janus.webRTCAdapter.browserDetails.version < 72) ? "plan-b" : "unified-plan";
+			}
+			var pc_constraints = {
+				"optional": [{"DtlsSrtpKeyAgreement": true}]
+			};
+			if(ipv6Support) {
+				pc_constraints.optional.push({"googIPv6":true});
+			}
+			// Any custom constraint to add?
+			if(callbacks.rtcConstraints && typeof callbacks.rtcConstraints === 'object') {
+				Janus.debug("Adding custom PeerConnection constraints:", callbacks.rtcConstraints);
+				for(var i in callbacks.rtcConstraints) {
+					pc_constraints.optional.push(callbacks.rtcConstraints[i]);
+				}
+			}
+			if(Janus.webRTCAdapter.browserDetails.browser === "edge") {
+				// This is Edge, enable BUNDLE explicitly
+				pc_config.bundlePolicy = "max-bundle";
+			}
+			Janus.log("Creating PeerConnection");
+			Janus.debug(pc_constraints);
+			config.pc = new RTCPeerConnection(pc_config, pc_constraints);
+			Janus.debug(config.pc);
+			if(config.pc.getStats) {	// FIXME
+				config.volume = {};
+				config.bitrate.value = "0 kbits/sec";
+			}
+			Janus.log("Preparing local SDP and gathering candidates (trickle=" + config.trickle + ")");
+			config.pc.oniceconnectionstatechange = function(e) {
+				if(config.pc)
+					pluginHandle.iceState(config.pc.iceConnectionState);
+			};
+			config.pc.onicecandidate = function(event) {
+				if (!event.candidate ||
+					(Janus.webRTCAdapter.browserDetails.browser === 'edge' && event.candidate.candidate.indexOf('endOfCandidates') > 0)) {
+					Janus.log("End of candidates.");
+					config.iceDone = true;
+					if(config.trickle === true) {
+						// Notify end of candidates
+						sendTrickleCandidate(handleId, {"completed": true});
+					} else {
+						// No trickle, time to send the complete SDP (including all candidates)
+						sendSDP(handleId, callbacks);
+					}
+				} else {
+					// JSON.stringify doesn't work on some WebRTC objects anymore
+					// See https://code.google.com/p/chromium/issues/detail?id=467366
+					var candidate = {
+						"candidate": event.candidate.candidate,
+						"sdpMid": event.candidate.sdpMid,
+						"sdpMLineIndex": event.candidate.sdpMLineIndex
+					};
+					if(config.trickle === true) {
+						// Send candidate
+						sendTrickleCandidate(handleId, candidate);
+					}
+				}
+			};
+			config.pc.ontrack = function(event) {
+				Janus.log("Handling Remote Track");
+				Janus.debug(event);
+				if(!event.streams)
+					return;
+				config.remoteStream = event.streams[0];
+				pluginHandle.onremotestream(config.remoteStream);
+				if(event.track.onended)
+					return;
+				Janus.log("Adding onended callback to track:", event.track);
+				event.track.onended = function(ev) {
+					Janus.log("Remote track muted/removed:", ev);
+					if(config.remoteStream) {
+						config.remoteStream.removeTrack(ev.target);
+						pluginHandle.onremotestream(config.remoteStream);
+					}
+				};
+				event.track.onmute = event.track.onended;
+				event.track.onunmute = function(ev) {
+					Janus.log("Remote track flowing again:", ev);
+					try {
+						config.remoteStream.addTrack(ev.target);
+						pluginHandle.onremotestream(config.remoteStream);
+					} catch(e) {
+						Janus.error(e);
+					};
+				};
+			};
+		}
+		if(addTracks && stream) {
+			Janus.log('Adding local stream');
+			var simulcast2 = (callbacks.simulcast2 === true);
+			stream.getTracks().forEach(function(track) {
+				Janus.log('Adding local track:', track);
+				if(!simulcast2) {
+					config.pc.addTrack(track, stream);
+				} else {
+					if(track.kind === "audio") {
+						config.pc.addTrack(track, stream);
+					} else {
+						Janus.log('Enabling rid-based simulcasting:', track);
+						const maxBitrates = getMaxBitrates(callbacks.simulcastMaxBitrates);
+						config.pc.addTransceiver(track, {
+							direction: "sendrecv",
+							streams: [stream],
+							sendEncodings: [
+								{ rid: "h", active: true, maxBitrate: maxBitrates.high },
+								{ rid: "m", active: true, maxBitrate: maxBitrates.medium, scaleResolutionDownBy: 2 },
+								{ rid: "l", active: true, maxBitrate: maxBitrates.low, scaleResolutionDownBy: 4 }
+							]
+						});
+					}
+				}
+			});
+		}
+		// Any data channel to create?
+		if(isDataEnabled(media) && !config.dataChannel[Janus.dataChanDefaultLabel]) {
+			Janus.log("Creating data channel");
+			createDataChannel(handleId, Janus.dataChanDefaultLabel, false);
+			config.pc.ondatachannel = function(event) {
+				Janus.log("Data channel created by Janus:", event);
+				createDataChannel(handleId, event.channel.label, event.channel);
+			};
+		}
+		// If there's a new local stream, let's notify the application
+		if(config.myStream)
+			pluginHandle.onlocalstream(config.myStream);
+		// Create offer/answer now
+		if(!jsep) {
+			createOffer(handleId, media, callbacks);
+		} else {
+			config.pc.setRemoteDescription(jsep)
+				.then(function() {
+					Janus.log("Remote description accepted!");
+					config.remoteSdp = jsep.sdp;
+					// Any trickle candidate we cached?
+					if(config.candidates && config.candidates.length > 0) {
+						for(var i = 0; i< config.candidates.length; i++) {
+							var candidate = config.candidates[i];
+							Janus.debug("Adding remote candidate:", candidate);
+							if(!candidate || candidate.completed === true) {
+								// end-of-candidates
+								config.pc.addIceCandidate(Janus.endOfCandidates);
+							} else {
+								// New candidate
+								config.pc.addIceCandidate(candidate);
+							}
+						}
+						config.candidates = [];
+					}
+					// Create the answer now
+					createAnswer(handleId, media, callbacks);
+				}, callbacks.error);
+		}
+	}
+
+	function prepareWebrtc(handleId, offer, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : webrtcError;
+		var jsep = callbacks.jsep;
+		if(offer && jsep) {
+			Janus.error("Provided a JSEP to a createOffer");
+			callbacks.error("Provided a JSEP to a createOffer");
+			return;
+		} else if(!offer && (!jsep || !jsep.type || !jsep.sdp)) {
+			Janus.error("A valid JSEP is required for createAnswer");
+			callbacks.error("A valid JSEP is required for createAnswer");
+			return;
+		}
+		/* Check that callbacks.media is a (not null) Object */
+		callbacks.media = (typeof callbacks.media === 'object' && callbacks.media) ? callbacks.media : { audio: true, video: true };
+		var media = callbacks.media;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		config.trickle = isTrickleEnabled(callbacks.trickle);
+		// Are we updating a session?
+		if(!config.pc) {
+			// Nope, new PeerConnection
+			media.update = false;
+			media.keepAudio = false;
+			media.keepVideo = false;
+		} else {
+			Janus.log("Updating existing media session");
+			media.update = true;
+			// Check if there's anything to add/remove/replace, or if we
+			// can go directly to preparing the new SDP offer or answer
+			if(callbacks.stream) {
+				// External stream: is this the same as the one we were using before?
+				if(callbacks.stream !== config.myStream) {
+					Janus.log("Renegotiation involves a new external stream");
+				}
+			} else {
+				// Check if there are changes on audio
+				if(media.addAudio) {
+					media.keepAudio = false;
+					media.replaceAudio = false;
+					media.removeAudio = false;
+					media.audioSend = true;
+					if(config.myStream && config.myStream.getAudioTracks() && config.myStream.getAudioTracks().length) {
+						Janus.error("Can't add audio stream, there already is one");
+						callbacks.error("Can't add audio stream, there already is one");
+						return;
+					}
+				} else if(media.removeAudio) {
+					media.keepAudio = false;
+					media.replaceAudio = false;
+					media.addAudio = false;
+					media.audioSend = false;
+				} else if(media.replaceAudio) {
+					media.keepAudio = false;
+					media.addAudio = false;
+					media.removeAudio = false;
+					media.audioSend = true;
+				}
+				if(!config.myStream) {
+					// No media stream: if we were asked to replace, it's actually an "add"
+					if(media.replaceAudio) {
+						media.keepAudio = false;
+						media.replaceAudio = false;
+						media.addAudio = true;
+						media.audioSend = true;
+					}
+					if(isAudioSendEnabled(media)) {
+						media.keepAudio = false;
+						media.addAudio = true;
+					}
+				} else {
+					if(!config.myStream.getAudioTracks() || config.myStream.getAudioTracks().length === 0) {
+						// No audio track: if we were asked to replace, it's actually an "add"
+						if(media.replaceAudio) {
+							media.keepAudio = false;
+							media.replaceAudio = false;
+							media.addAudio = true;
+							media.audioSend = true;
+						}
+						if(isAudioSendEnabled(media)) {
+							media.keepAudio = false;
+							media.addAudio = true;
+						}
+					} else {
+						// We have an audio track: should we keep it as it is?
+						if(isAudioSendEnabled(media) &&
+							!media.removeAudio && !media.replaceAudio) {
+							media.keepAudio = true;
+						}
+					}
+				}
+				// Check if there are changes on video
+				if(media.addVideo) {
+					media.keepVideo = false;
+					media.replaceVideo = false;
+					media.removeVideo = false;
+					media.videoSend = true;
+					if(config.myStream && config.myStream.getVideoTracks() && config.myStream.getVideoTracks().length) {
+						Janus.error("Can't add video stream, there already is one");
+						callbacks.error("Can't add video stream, there already is one");
+						return;
+					}
+				} else if(media.removeVideo) {
+					media.keepVideo = false;
+					media.replaceVideo = false;
+					media.addVideo = false;
+					media.videoSend = false;
+				} else if(media.replaceVideo) {
+					media.keepVideo = false;
+					media.addVideo = false;
+					media.removeVideo = false;
+					media.videoSend = true;
+				}
+				if(!config.myStream) {
+					// No media stream: if we were asked to replace, it's actually an "add"
+					if(media.replaceVideo) {
+						media.keepVideo = false;
+						media.replaceVideo = false;
+						media.addVideo = true;
+						media.videoSend = true;
+					}
+					if(isVideoSendEnabled(media)) {
+						media.keepVideo = false;
+						media.addVideo = true;
+					}
+				} else {
+					if(!config.myStream.getVideoTracks() || config.myStream.getVideoTracks().length === 0) {
+						// No video track: if we were asked to replace, it's actually an "add"
+						if(media.replaceVideo) {
+							media.keepVideo = false;
+							media.replaceVideo = false;
+							media.addVideo = true;
+							media.videoSend = true;
+						}
+						if(isVideoSendEnabled(media)) {
+							media.keepVideo = false;
+							media.addVideo = true;
+						}
+					} else {
+						// We have a video track: should we keep it as it is?
+						if(isVideoSendEnabled(media) &&
+							!media.removeVideo && !media.replaceVideo) {
+							media.keepVideo = true;
+						}
+					}
+				}
+				// Data channels can only be added
+				if(media.addData)
+					media.data = true;
+			}
+			// If we're updating and keeping all tracks, let's skip the getUserMedia part
+			if((isAudioSendEnabled(media) && media.keepAudio) &&
+				(isVideoSendEnabled(media) && media.keepVideo)) {
+				pluginHandle.consentDialog(false);
+				streamsDone(handleId, jsep, media, callbacks, config.myStream);
+				return;
+			}
+		}
+		// If we're updating, check if we need to remove/replace one of the tracks
+		if(media.update && !config.streamExternal) {
+			if(media.removeAudio || media.replaceAudio) {
+				if(config.myStream && config.myStream.getAudioTracks() && config.myStream.getAudioTracks().length) {
+					var s = config.myStream.getAudioTracks()[0];
+					Janus.log("Removing audio track:", s);
+					config.myStream.removeTrack(s);
+					try {
+						s.stop();
+					} catch(e) {};
+				}
+				if(config.pc.getSenders() && config.pc.getSenders().length) {
+					var ra = true;
+					if(media.replaceAudio && Janus.unifiedPlan) {
+						// We can use replaceTrack
+						ra = false;
+					}
+					if(ra) {
+						for(var s of config.pc.getSenders()) {
+							if(s && s.track && s.track.kind === "audio") {
+								Janus.log("Removing audio sender:", s);
+								config.pc.removeTrack(s);
+							}
+						}
+					}
+				}
+			}
+			if(media.removeVideo || media.replaceVideo) {
+				if(config.myStream && config.myStream.getVideoTracks() && config.myStream.getVideoTracks().length) {
+					var s = config.myStream.getVideoTracks()[0];
+					Janus.log("Removing video track:", s);
+					config.myStream.removeTrack(s);
+					try {
+						s.stop();
+					} catch(e) {};
+				}
+				if(config.pc.getSenders() && config.pc.getSenders().length) {
+					var rv = true;
+					if(media.replaceVideo && Janus.unifiedPlan) {
+						// We can use replaceTrack
+						rv = false;
+					}
+					if(rv) {
+						for(var s of config.pc.getSenders()) {
+							if(s && s.track && s.track.kind === "video") {
+								Janus.log("Removing video sender:", s);
+								config.pc.removeTrack(s);
+							}
+						}
+					}
+				}
+			}
+		}
+		// Was a MediaStream object passed, or do we need to take care of that?
+		if(callbacks.stream) {
+			var stream = callbacks.stream;
+			Janus.log("MediaStream provided by the application");
+			Janus.debug(stream);
+			// If this is an update, let's check if we need to release the previous stream
+			if(media.update) {
+				if(config.myStream && config.myStream !== callbacks.stream && !config.streamExternal) {
+					// We're replacing a stream we captured ourselves with an external one
+					try {
+						// Try a MediaStreamTrack.stop() for each track
+						var tracks = config.myStream.getTracks();
+						for(var mst of tracks) {
+							Janus.log(mst);
+							if(mst)
+								mst.stop();
+						}
+					} catch(e) {
+						// Do nothing if this fails
+					}
+					config.myStream = null;
+				}
+			}
+			// Skip the getUserMedia part
+			config.streamExternal = true;
+			pluginHandle.consentDialog(false);
+			streamsDone(handleId, jsep, media, callbacks, stream);
+			return;
+		}
+		if(isAudioSendEnabled(media) || isVideoSendEnabled(media)) {
+			if(!Janus.isGetUserMediaAvailable()) {
+				callbacks.error("getUserMedia not available");
+				return;
+			}
+			var constraints = { mandatory: {}, optional: []};
+			pluginHandle.consentDialog(true);
+			var audioSupport = isAudioSendEnabled(media);
+			if(audioSupport && media && typeof media.audio === 'object')
+				audioSupport = media.audio;
+			var videoSupport = isVideoSendEnabled(media);
+			if(videoSupport && media) {
+				var simulcast = (callbacks.simulcast === true);
+				var simulcast2 = (callbacks.simulcast2 === true);
+				if((simulcast || simulcast2) && !jsep && !media.video)
+					media.video = "hires";
+				if(media.video && media.video != 'screen' && media.video != 'window') {
+					if(typeof media.video === 'object') {
+						videoSupport = media.video;
+					} else {
+						var width = 0;
+						var height = 0, maxHeight = 0;
+						if(media.video === 'lowres') {
+							// Small resolution, 4:3
+							height = 240;
+							maxHeight = 240;
+							width = 320;
+						} else if(media.video === 'lowres-16:9') {
+							// Small resolution, 16:9
+							height = 180;
+							maxHeight = 180;
+							width = 320;
+						} else if(media.video === 'hires' || media.video === 'hires-16:9' || media.video === 'hdres') {
+							// High(HD) resolution is only 16:9
+							height = 720;
+							maxHeight = 720;
+							width = 1280;
+						} else if(media.video === 'fhdres') {
+							// Full HD resolution is only 16:9
+							height = 1080;
+							maxHeight = 1080;
+							width = 1920;
+						} else if(media.video === '4kres') {
+							// 4K resolution is only 16:9
+							height = 2160;
+							maxHeight = 2160;
+							width = 3840;
+						} else if(media.video === 'stdres') {
+							// Normal resolution, 4:3
+							height = 480;
+							maxHeight = 480;
+							width  = 640;
+						} else if(media.video === 'stdres-16:9') {
+							// Normal resolution, 16:9
+							height = 360;
+							maxHeight = 360;
+							width = 640;
+						} else {
+							Janus.log("Default video setting is stdres 4:3");
+							height = 480;
+							maxHeight = 480;
+							width = 640;
+						}
+						Janus.log("Adding media constraint:", media.video);
+						videoSupport = {
+							'height': {'ideal': height},
+							'width':  {'ideal': width}
+						};
+						Janus.log("Adding video constraint:", videoSupport);
+					}
+				} else if(media.video === 'screen' || media.video === 'window') {
+					if(!media.screenshareFrameRate) {
+						media.screenshareFrameRate = 3;
+					}
+					if(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
+						// The new experimental getDisplayMedia API is available, let's use that
+						// https://groups.google.com/forum/#!topic/discuss-webrtc/Uf0SrR4uxzk
+						// https://webrtchacks.com/chrome-screensharing-getdisplaymedia/
+						navigator.mediaDevices.getDisplayMedia({ video: true, audio: media.captureDesktopAudio })
+							.then(function(stream) {
+								pluginHandle.consentDialog(false);
+								if(isAudioSendEnabled(media) && !media.keepAudio) {
+									navigator.mediaDevices.getUserMedia({ audio: true, video: false })
+										.then(function (audioStream) {
+											stream.addTrack(audioStream.getAudioTracks()[0]);
+											streamsDone(handleId, jsep, media, callbacks, stream);
+										})
+								} else {
+									streamsDone(handleId, jsep, media, callbacks, stream);
+								}
+							}, function (error) {
+								pluginHandle.consentDialog(false);
+								callbacks.error(error);
+							});
+						return;
+					}
+					// We're going to try and use the extension for Chrome 34+, the old approach
+					// for older versions of Chrome, or the experimental support in Firefox 33+
+					function callbackUserMedia (error, stream) {
+						pluginHandle.consentDialog(false);
+						if(error) {
+							callbacks.error(error);
+						} else {
+							streamsDone(handleId, jsep, media, callbacks, stream);
+						}
+					};
+					function getScreenMedia(constraints, gsmCallback, useAudio) {
+						Janus.log("Adding media constraint (screen capture)");
+						Janus.debug(constraints);
+						navigator.mediaDevices.getUserMedia(constraints)
+							.then(function(stream) {
+								if(useAudio) {
+									navigator.mediaDevices.getUserMedia({ audio: true, video: false })
+										.then(function (audioStream) {
+											stream.addTrack(audioStream.getAudioTracks()[0]);
+											gsmCallback(null, stream);
+										})
+								} else {
+									gsmCallback(null, stream);
+								}
+							})
+							.catch(function(error) { pluginHandle.consentDialog(false); gsmCallback(error); });
+					};
+					if(Janus.webRTCAdapter.browserDetails.browser === 'chrome') {
+						var chromever = Janus.webRTCAdapter.browserDetails.version;
+						var maxver = 33;
+						if(window.navigator.userAgent.match('Linux'))
+							maxver = 35;	// "known" crash in chrome 34 and 35 on linux
+						if(chromever >= 26 && chromever <= maxver) {
+							// Chrome 26->33 requires some awkward chrome://flags manipulation
+							constraints = {
+								video: {
+									mandatory: {
+										googLeakyBucket: true,
+										maxWidth: window.screen.width,
+										maxHeight: window.screen.height,
+										minFrameRate: media.screenshareFrameRate,
+										maxFrameRate: media.screenshareFrameRate,
+										chromeMediaSource: 'screen'
+									}
+								},
+								audio: isAudioSendEnabled(media) && !media.keepAudio
+							};
+							getScreenMedia(constraints, callbackUserMedia);
+						} else {
+							// Chrome 34+ requires an extension
+							Janus.extension.getScreen(function (error, sourceId) {
+								if (error) {
+									pluginHandle.consentDialog(false);
+									return callbacks.error(error);
+								}
+								constraints = {
+									audio: false,
+									video: {
+										mandatory: {
+											chromeMediaSource: 'desktop',
+											maxWidth: window.screen.width,
+											maxHeight: window.screen.height,
+											minFrameRate: media.screenshareFrameRate,
+											maxFrameRate: media.screenshareFrameRate,
+										},
+										optional: [
+											{googLeakyBucket: true},
+											{googTemporalLayeredScreencast: true}
+										]
+									}
+								};
+								constraints.video.mandatory.chromeMediaSourceId = sourceId;
+								getScreenMedia(constraints, callbackUserMedia,
+									isAudioSendEnabled(media) && !media.keepAudio);
+							});
+						}
+					} else if(Janus.webRTCAdapter.browserDetails.browser === 'firefox') {
+						if(Janus.webRTCAdapter.browserDetails.version >= 33) {
+							// Firefox 33+ has experimental support for screen sharing
+							constraints = {
+								video: {
+									mozMediaSource: media.video,
+									mediaSource: media.video
+								},
+								audio: isAudioSendEnabled(media) && !media.keepAudio
+							};
+							getScreenMedia(constraints, function (err, stream) {
+								callbackUserMedia(err, stream);
+								// Workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=1045810
+								if (!err) {
+									var lastTime = stream.currentTime;
+									var polly = window.setInterval(function () {
+										if(!stream)
+											window.clearInterval(polly);
+										if(stream.currentTime == lastTime) {
+											window.clearInterval(polly);
+											if(stream.onended) {
+												stream.onended();
+											}
+										}
+										lastTime = stream.currentTime;
+									}, 500);
+								}
+							});
+						} else {
+							var error = new Error('NavigatorUserMediaError');
+							error.name = 'Your version of Firefox does not support screen sharing, please install Firefox 33 (or more recent versions)';
+							pluginHandle.consentDialog(false);
+							callbacks.error(error);
+							return;
+						}
+					}
+					return;
+				}
+			}
+			// If we got here, we're not screensharing
+			if(!media || media.video !== 'screen') {
+				// Check whether all media sources are actually available or not
+				navigator.mediaDevices.enumerateDevices().then(function(devices) {
+					var audioExist = devices.some(function(device) {
+							return device.kind === 'audioinput';
+						}),
+						videoExist = isScreenSendEnabled(media) || devices.some(function(device) {
+							return device.kind === 'videoinput';
+						});
+
+					// Check whether a missing device is really a problem
+					var audioSend = isAudioSendEnabled(media);
+					var videoSend = isVideoSendEnabled(media);
+					var needAudioDevice = isAudioSendRequired(media);
+					var needVideoDevice = isVideoSendRequired(media);
+					if(audioSend || videoSend || needAudioDevice || needVideoDevice) {
+						// We need to send either audio or video
+						var haveAudioDevice = audioSend ? audioExist : false;
+						var haveVideoDevice = videoSend ? videoExist : false;
+						if(!haveAudioDevice && !haveVideoDevice) {
+							// FIXME Should we really give up, or just assume recvonly for both?
+							pluginHandle.consentDialog(false);
+							callbacks.error('No capture device found');
+							return false;
+						} else if(!haveAudioDevice && needAudioDevice) {
+							pluginHandle.consentDialog(false);
+							callbacks.error('Audio capture is required, but no capture device found');
+							return false;
+						} else if(!haveVideoDevice && needVideoDevice) {
+							pluginHandle.consentDialog(false);
+							callbacks.error('Video capture is required, but no capture device found');
+							return false;
+						}
+					}
+
+					var gumConstraints = {
+						audio: (audioExist && !media.keepAudio) ? audioSupport : false,
+						video: (videoExist && !media.keepVideo) ? videoSupport : false
+					};
+					Janus.debug("getUserMedia constraints", gumConstraints);
+					if (!gumConstraints.audio && !gumConstraints.video) {
+						pluginHandle.consentDialog(false);
+						streamsDone(handleId, jsep, media, callbacks, stream);
+					} else {
+						navigator.mediaDevices.getUserMedia(gumConstraints)
+							.then(function(stream) {
+								pluginHandle.consentDialog(false);
+								streamsDone(handleId, jsep, media, callbacks, stream);
+							}).catch(function(error) {
+							pluginHandle.consentDialog(false);
+							callbacks.error({code: error.code, name: error.name, message: error.message});
+						});
+					}
+				})
+					.catch(function(error) {
+						pluginHandle.consentDialog(false);
+						callbacks.error('enumerateDevices error', error);
+					});
+			}
+		} else {
+			// No need to do a getUserMedia, create offer/answer right away
+			streamsDone(handleId, jsep, media, callbacks);
+		}
+	}
+
+	function prepareWebrtcPeer(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : webrtcError;
+		var jsep = callbacks.jsep;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(jsep) {
+			if(!config.pc) {
+				Janus.warn("Wait, no PeerConnection?? if this is an answer, use createAnswer and not handleRemoteJsep");
+				callbacks.error("No PeerConnection: if this is an answer, use createAnswer and not handleRemoteJsep");
+				return;
+			}
+			config.pc.setRemoteDescription(jsep)
+				.then(function() {
+					Janus.log("Remote description accepted!");
+					config.remoteSdp = jsep.sdp;
+					// Any trickle candidate we cached?
+					if(config.candidates && config.candidates.length > 0) {
+						for(var i = 0; i< config.candidates.length; i++) {
+							var candidate = config.candidates[i];
+							Janus.debug("Adding remote candidate:", candidate);
+							if(!candidate || candidate.completed === true) {
+								// end-of-candidates
+								config.pc.addIceCandidate(Janus.endOfCandidates);
+							} else {
+								// New candidate
+								config.pc.addIceCandidate(candidate);
+							}
+						}
+						config.candidates = [];
+					}
+					// Done
+					callbacks.success();
+				}, callbacks.error);
+		} else {
+			callbacks.error("Invalid JSEP");
+		}
+	}
+
+	function createOffer(handleId, media, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		callbacks.customizeSdp = (typeof callbacks.customizeSdp == "function") ? callbacks.customizeSdp : Janus.noop;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		var simulcast = (callbacks.simulcast === true);
+		if(!simulcast) {
+			Janus.log("Creating offer (iceDone=" + config.iceDone + ")");
+		} else {
+			Janus.log("Creating offer (iceDone=" + config.iceDone + ", simulcast=" + simulcast + ")");
+		}
+		// https://code.google.com/p/webrtc/issues/detail?id=3508
+		var mediaConstraints = {};
+		if(Janus.unifiedPlan) {
+			// We can use Transceivers
+			var audioTransceiver = null, videoTransceiver = null;
+			var transceivers = config.pc.getTransceivers();
+			if(transceivers && transceivers.length > 0) {
+				for(var t of transceivers) {
+					if((t.sender && t.sender.track && t.sender.track.kind === "audio") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")) {
+						if(!audioTransceiver)
+							audioTransceiver = t;
+						continue;
+					}
+					if((t.sender && t.sender.track && t.sender.track.kind === "video") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")) {
+						if(!videoTransceiver)
+							videoTransceiver = t;
+						continue;
+					}
+				}
+			}
+			// Handle audio (and related changes, if any)
+			var audioSend = isAudioSendEnabled(media);
+			var audioRecv = isAudioRecvEnabled(media);
+			if(!audioSend && !audioRecv) {
+				// Audio disabled: have we removed it?
+				if(media.removeAudio && audioTransceiver) {
+					if (audioTransceiver.setDirection) {
+						audioTransceiver.setDirection("inactive");
+					} else {
+						audioTransceiver.direction = "inactive";
+					}
+					Janus.log("Setting audio transceiver to inactive:", audioTransceiver);
+				}
+			} else {
+				// Take care of audio m-line
+				if(audioSend && audioRecv) {
+					if(audioTransceiver) {
+						if (audioTransceiver.setDirection) {
+							audioTransceiver.setDirection("sendrecv");
+						} else {
+							audioTransceiver.direction = "sendrecv";
+						}
+						Janus.log("Setting audio transceiver to sendrecv:", audioTransceiver);
+					}
+				} else if(audioSend && !audioRecv) {
+					if(audioTransceiver) {
+						if (audioTransceiver.setDirection) {
+							audioTransceiver.setDirection("sendonly");
+						} else {
+							audioTransceiver.direction = "sendonly";
+						}
+						Janus.log("Setting audio transceiver to sendonly:", audioTransceiver);
+					}
+				} else if(!audioSend && audioRecv) {
+					if(audioTransceiver) {
+						if (audioTransceiver.setDirection) {
+							audioTransceiver.setDirection("recvonly");
+						} else {
+							audioTransceiver.direction = "recvonly";
+						}
+						Janus.log("Setting audio transceiver to recvonly:", audioTransceiver);
+					} else {
+						// In theory, this is the only case where we might not have a transceiver yet
+						audioTransceiver = config.pc.addTransceiver("audio", { direction: "recvonly" });
+						Janus.log("Adding recvonly audio transceiver:", audioTransceiver);
+					}
+				}
+			}
+			// Handle video (and related changes, if any)
+			var videoSend = isVideoSendEnabled(media);
+			var videoRecv = isVideoRecvEnabled(media);
+			if(!videoSend && !videoRecv) {
+				// Video disabled: have we removed it?
+				if(media.removeVideo && videoTransceiver) {
+					if (videoTransceiver.setDirection) {
+						videoTransceiver.setDirection("inactive");
+					} else {
+						videoTransceiver.direction = "inactive";
+					}
+					Janus.log("Setting video transceiver to inactive:", videoTransceiver);
+				}
+			} else {
+				// Take care of video m-line
+				if(videoSend && videoRecv) {
+					if(videoTransceiver) {
+						if (videoTransceiver.setDirection) {
+							videoTransceiver.setDirection("sendrecv");
+						} else {
+							videoTransceiver.direction = "sendrecv";
+						}
+						Janus.log("Setting video transceiver to sendrecv:", videoTransceiver);
+					}
+				} else if(videoSend && !videoRecv) {
+					if(videoTransceiver) {
+						if (videoTransceiver.setDirection) {
+							videoTransceiver.setDirection("sendonly");
+						} else {
+							videoTransceiver.direction = "sendonly";
+						}
+						Janus.log("Setting video transceiver to sendonly:", videoTransceiver);
+					}
+				} else if(!videoSend && videoRecv) {
+					if(videoTransceiver) {
+						if (videoTransceiver.setDirection) {
+							videoTransceiver.setDirection("recvonly");
+						} else {
+							videoTransceiver.direction = "recvonly";
+						}
+						Janus.log("Setting video transceiver to recvonly:", videoTransceiver);
+					} else {
+						// In theory, this is the only case where we might not have a transceiver yet
+						videoTransceiver = config.pc.addTransceiver("video", { direction: "recvonly" });
+						Janus.log("Adding recvonly video transceiver:", videoTransceiver);
+					}
+				}
+			}
+		} else {
+			mediaConstraints["offerToReceiveAudio"] = isAudioRecvEnabled(media);
+			mediaConstraints["offerToReceiveVideo"] = isVideoRecvEnabled(media);
+		}
+		var iceRestart = (callbacks.iceRestart === true);
+		if(iceRestart) {
+			mediaConstraints["iceRestart"] = true;
+		}
+		Janus.debug(mediaConstraints);
+		// Check if this is Firefox and we've been asked to do simulcasting
+		var sendVideo = isVideoSendEnabled(media);
+		if(sendVideo && simulcast && Janus.webRTCAdapter.browserDetails.browser === "firefox") {
+			// FIXME Based on https://gist.github.com/voluntas/088bc3cc62094730647b
+			Janus.log("Enabling Simulcasting for Firefox (RID)");
+			var sender = config.pc.getSenders().find(function(s) {return s.track.kind == "video"});
+			if(sender) {
+				var parameters = sender.getParameters();
+				if(!parameters)
+					parameters = {};
+
+
+				const maxBitrates = getMaxBitrates(callbacks.simulcastMaxBitrates);
+				parameters.encodings = [
+					{ rid: "h", active: true, maxBitrate: maxBitrates.high },
+					{ rid: "m", active: true, maxBitrate: maxBitrates.medium, scaleResolutionDownBy: 2 },
+					{ rid: "l", active: true, maxBitrate: maxBitrates.low, scaleResolutionDownBy: 4 }
+				];
+				sender.setParameters(parameters);
+			}
+		}
+		config.pc.createOffer(mediaConstraints)
+			.then(function(offer) {
+				Janus.debug(offer);
+				// JSON.stringify doesn't work on some WebRTC objects anymore
+				// See https://code.google.com/p/chromium/issues/detail?id=467366
+				var jsep = {
+					"type": offer.type,
+					"sdp": offer.sdp
+				};
+				callbacks.customizeSdp(jsep);
+				offer.sdp = jsep.sdp;
+				Janus.log("Setting local description");
+				if(sendVideo && simulcast) {
+					// This SDP munging only works with Chrome (Safari STP may support it too)
+					if(Janus.webRTCAdapter.browserDetails.browser === "chrome" ||
+						Janus.webRTCAdapter.browserDetails.browser === "safari") {
+						Janus.log("Enabling Simulcasting for Chrome (SDP munging)");
+						offer.sdp = mungeSdpForSimulcasting(offer.sdp);
+					} else if(Janus.webRTCAdapter.browserDetails.browser !== "firefox") {
+						Janus.warn("simulcast=true, but this is not Chrome nor Firefox, ignoring");
+					}
+				}
+				config.mySdp = offer.sdp;
+				config.pc.setLocalDescription(offer)
+					.catch(callbacks.error);
+				config.mediaConstraints = mediaConstraints;
+				if(!config.iceDone && !config.trickle) {
+					// Don't do anything until we have all candidates
+					Janus.log("Waiting for all candidates...");
+					return;
+				}
+				Janus.log("Offer ready");
+				Janus.debug(callbacks);
+				callbacks.success(offer);
+			}, callbacks.error);
+	}
+
+	function createAnswer(handleId, media, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		callbacks.customizeSdp = (typeof callbacks.customizeSdp == "function") ? callbacks.customizeSdp : Janus.noop;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			callbacks.error("Invalid handle");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		var simulcast = (callbacks.simulcast === true);
+		if(!simulcast) {
+			Janus.log("Creating answer (iceDone=" + config.iceDone + ")");
+		} else {
+			Janus.log("Creating answer (iceDone=" + config.iceDone + ", simulcast=" + simulcast + ")");
+		}
+		var mediaConstraints = null;
+		if(Janus.unifiedPlan) {
+			// We can use Transceivers
+			mediaConstraints = {};
+			var audioTransceiver = null, videoTransceiver = null;
+			var transceivers = config.pc.getTransceivers();
+			if(transceivers && transceivers.length > 0) {
+				for(var t of transceivers) {
+					if((t.sender && t.sender.track && t.sender.track.kind === "audio") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")) {
+						if(!audioTransceiver)
+							audioTransceiver = t;
+						continue;
+					}
+					if((t.sender && t.sender.track && t.sender.track.kind === "video") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")) {
+						if(!videoTransceiver)
+							videoTransceiver = t;
+						continue;
+					}
+				}
+			}
+			// Handle audio (and related changes, if any)
+			var audioSend = isAudioSendEnabled(media);
+			var audioRecv = isAudioRecvEnabled(media);
+			if(!audioSend && !audioRecv) {
+				// Audio disabled: have we removed it?
+				if(media.removeAudio && audioTransceiver) {
+					try {
+						if (audioTransceiver.setDirection) {
+							audioTransceiver.setDirection("inactive");
+						} else {
+							audioTransceiver.direction = "inactive";
+						}
+						Janus.log("Setting audio transceiver to inactive:", audioTransceiver);
+					} catch(e) {
+						Janus.error(e);
+					}
+				}
+			} else {
+				// Take care of audio m-line
+				if(audioSend && audioRecv) {
+					if(audioTransceiver) {
+						try {
+							if (audioTransceiver.setDirection) {
+								audioTransceiver.setDirection("sendrecv");
+							} else {
+								audioTransceiver.direction = "sendrecv";
+							}
+							Janus.log("Setting audio transceiver to sendrecv:", audioTransceiver);
+						} catch(e) {
+							Janus.error(e);
+						}
+					}
+				} else if(audioSend && !audioRecv) {
+					try {
+						if(audioTransceiver) {
+							if (audioTransceiver.setDirection) {
+								audioTransceiver.setDirection("sendonly");
+							} else {
+								audioTransceiver.direction = "sendonly";
+							}
+							Janus.log("Setting audio transceiver to sendonly:", audioTransceiver);
+						}
+					} catch(e) {
+						Janus.error(e);
+					}
+				} else if(!audioSend && audioRecv) {
+					if(audioTransceiver) {
+						try {
+							if (audioTransceiver.setDirection) {
+								audioTransceiver.setDirection("recvonly");
+							} else {
+								audioTransceiver.direction = "recvonly";
+							}
+							Janus.log("Setting audio transceiver to recvonly:", audioTransceiver);
+						} catch(e) {
+							Janus.error(e);
+						}
+					} else {
+						// In theory, this is the only case where we might not have a transceiver yet
+						audioTransceiver = config.pc.addTransceiver("audio", { direction: "recvonly" });
+						Janus.log("Adding recvonly audio transceiver:", audioTransceiver);
+					}
+				}
+			}
+			// Handle video (and related changes, if any)
+			var videoSend = isVideoSendEnabled(media);
+			var videoRecv = isVideoRecvEnabled(media);
+			if(!videoSend && !videoRecv) {
+				// Video disabled: have we removed it?
+				if(media.removeVideo && videoTransceiver) {
+					try {
+						if (videoTransceiver.setDirection) {
+							videoTransceiver.setDirection("inactive");
+						} else {
+							videoTransceiver.direction = "inactive";
+						}
+						Janus.log("Setting video transceiver to inactive:", videoTransceiver);
+					} catch(e) {
+						Janus.error(e);
+					}
+				}
+			} else {
+				// Take care of video m-line
+				if(videoSend && videoRecv) {
+					if(videoTransceiver) {
+						try {
+							if (videoTransceiver.setDirection) {
+								videoTransceiver.setDirection("sendrecv");
+							} else {
+								videoTransceiver.direction = "sendrecv";
+							}
+							Janus.log("Setting video transceiver to sendrecv:", videoTransceiver);
+						} catch(e) {
+							Janus.error(e);
+						}
+					}
+				} else if(videoSend && !videoRecv) {
+					if(videoTransceiver) {
+						try {
+							if (videoTransceiver.setDirection) {
+								videoTransceiver.setDirection("sendonly");
+							} else {
+								videoTransceiver.direction = "sendonly";
+							}
+							Janus.log("Setting video transceiver to sendonly:", videoTransceiver);
+						} catch(e) {
+							Janus.error(e);
+						}
+					}
+				} else if(!videoSend && videoRecv) {
+					if(videoTransceiver) {
+						try {
+							if (videoTransceiver.setDirection) {
+								videoTransceiver.setDirection("recvonly");
+							} else {
+								videoTransceiver.direction = "recvonly";
+							}
+							Janus.log("Setting video transceiver to recvonly:", videoTransceiver);
+						} catch(e) {
+							Janus.error(e);
+						}
+					} else {
+						// In theory, this is the only case where we might not have a transceiver yet
+						videoTransceiver = config.pc.addTransceiver("video", { direction: "recvonly" });
+						Janus.log("Adding recvonly video transceiver:", videoTransceiver);
+					}
+				}
+			}
+		} else {
+			if(Janus.webRTCAdapter.browserDetails.browser === "firefox" || Janus.webRTCAdapter.browserDetails.browser === "edge") {
+				mediaConstraints = {
+					offerToReceiveAudio: isAudioRecvEnabled(media),
+					offerToReceiveVideo: isVideoRecvEnabled(media)
+				};
+			} else {
+				mediaConstraints = {
+					mandatory: {
+						OfferToReceiveAudio: isAudioRecvEnabled(media),
+						OfferToReceiveVideo: isVideoRecvEnabled(media)
+					}
+				};
+			}
+		}
+		Janus.debug(mediaConstraints);
+		// Check if this is Firefox and we've been asked to do simulcasting
+		var sendVideo = isVideoSendEnabled(media);
+		if(sendVideo && simulcast && Janus.webRTCAdapter.browserDetails.browser === "firefox") {
+			// FIXME Based on https://gist.github.com/voluntas/088bc3cc62094730647b
+			Janus.log("Enabling Simulcasting for Firefox (RID)");
+			var sender = config.pc.getSenders()[1];
+			Janus.log(sender);
+			var parameters = sender.getParameters();
+			Janus.log(parameters);
+
+			const maxBitrates = getMaxBitrates(callbacks.simulcastMaxBitrates);
+			sender.setParameters({encodings: [
+					{ rid: "high", active: true, priority: "high", maxBitrate: maxBitrates.high },
+					{ rid: "medium", active: true, priority: "medium", maxBitrate: maxBitrates.medium },
+					{ rid: "low", active: true, priority: "low", maxBitrate: maxBitrates.low }
+				]});
+		}
+		config.pc.createAnswer(mediaConstraints)
+			.then(function(answer) {
+				Janus.debug(answer);
+				// JSON.stringify doesn't work on some WebRTC objects anymore
+				// See https://code.google.com/p/chromium/issues/detail?id=467366
+				var jsep = {
+					"type": answer.type,
+					"sdp": answer.sdp
+				};
+				callbacks.customizeSdp(jsep);
+				answer.sdp = jsep.sdp;
+				Janus.log("Setting local description");
+				if(sendVideo && simulcast) {
+					// This SDP munging only works with Chrome
+					if(Janus.webRTCAdapter.browserDetails.browser === "chrome") {
+						// FIXME Apparently trying to simulcast when answering breaks video in Chrome...
+						//~ Janus.log("Enabling Simulcasting for Chrome (SDP munging)");
+						//~ answer.sdp = mungeSdpForSimulcasting(answer.sdp);
+						Janus.warn("simulcast=true, but this is an answer, and video breaks in Chrome if we enable it");
+					} else if(Janus.webRTCAdapter.browserDetails.browser !== "firefox") {
+						Janus.warn("simulcast=true, but this is not Chrome nor Firefox, ignoring");
+					}
+				}
+				config.mySdp = answer.sdp;
+				config.pc.setLocalDescription(answer)
+					.catch(callbacks.error);
+				config.mediaConstraints = mediaConstraints;
+				if(!config.iceDone && !config.trickle) {
+					// Don't do anything until we have all candidates
+					Janus.log("Waiting for all candidates...");
+					return;
+				}
+				callbacks.success(answer);
+			}, callbacks.error);
+	}
+
+	function sendSDP(handleId, callbacks) {
+		callbacks = callbacks || {};
+		callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+		callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle, not sending anything");
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		Janus.log("Sending offer/answer SDP...");
+		if(!config.mySdp) {
+			Janus.warn("Local SDP instance is invalid, not sending anything...");
+			return;
+		}
+		config.mySdp = {
+			"type": config.pc.localDescription.type,
+			"sdp": config.pc.localDescription.sdp
+		};
+		if(config.trickle === false)
+			config.mySdp["trickle"] = false;
+		Janus.debug(callbacks);
+		config.sdpSent = true;
+		callbacks.success(config.mySdp);
+	}
+
+	function getVolume(handleId, remote) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return 0;
+		}
+		var stream = remote ? "remote" : "local";
+		var config = pluginHandle.webrtcStuff;
+		if(!config.volume[stream])
+			config.volume[stream] = { value: 0 };
+		// Start getting the volume, if audioLevel in getStats is supported (apparently
+		// they're only available in Chrome/Safari right now: https://webrtc-stats.callstats.io/)
+		if(config.pc.getStats && (Janus.webRTCAdapter.browserDetails.browser === "chrome" ||
+			Janus.webRTCAdapter.browserDetails.browser === "safari")) {
+			if(remote && !config.remoteStream) {
+				Janus.warn("Remote stream unavailable");
+				return 0;
+			} else if(!remote && !config.myStream) {
+				Janus.warn("Local stream unavailable");
+				return 0;
+			}
+			if(!config.volume[stream].timer) {
+				Janus.log("Starting " + stream + " volume monitor");
+				config.volume[stream].timer = setInterval(function() {
+					config.pc.getStats()
+						.then(function(stats) {
+							stats.forEach(function (res) {
+								if(!res || res.kind !== "audio")
+									return;
+								if((remote && !res.remoteSource) || (!remote && res.type !== "media-source"))
+									return;
+								config.volume[stream].value = (res.audioLevel ? res.audioLevel : 0);
+							});
+						});
+				}, 200);
+				return 0;	// We don't have a volume to return yet
+			}
+			return config.volume[stream].value;
+		} else {
+			// audioInputLevel and audioOutputLevel seem only available in Chrome? audioLevel
+			// seems to be available on Chrome and Firefox, but they don't seem to work
+			Janus.warn("Getting the " + stream + " volume unsupported by browser");
+			return 0;
+		}
+	}
+
+	function isMuted(handleId, video) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return true;
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(!config.pc) {
+			Janus.warn("Invalid PeerConnection");
+			return true;
+		}
+		if(!config.myStream) {
+			Janus.warn("Invalid local MediaStream");
+			return true;
+		}
+		if(video) {
+			// Check video track
+			if(!config.myStream.getVideoTracks() || config.myStream.getVideoTracks().length === 0) {
+				Janus.warn("No video track");
+				return true;
+			}
+			return !config.myStream.getVideoTracks()[0].enabled;
+		} else {
+			// Check audio track
+			if(!config.myStream.getAudioTracks() || config.myStream.getAudioTracks().length === 0) {
+				Janus.warn("No audio track");
+				return true;
+			}
+			return !config.myStream.getAudioTracks()[0].enabled;
+		}
+	}
+
+	function mute(handleId, video, mute) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return false;
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(!config.pc) {
+			Janus.warn("Invalid PeerConnection");
+			return false;
+		}
+		if(!config.myStream) {
+			Janus.warn("Invalid local MediaStream");
+			return false;
+		}
+		if(video) {
+			// Mute/unmute video track
+			if(!config.myStream.getVideoTracks() || config.myStream.getVideoTracks().length === 0) {
+				Janus.warn("No video track");
+				return false;
+			}
+			config.myStream.getVideoTracks()[0].enabled = mute ? false : true;
+			return true;
+		} else {
+			// Mute/unmute audio track
+			if(!config.myStream.getAudioTracks() || config.myStream.getAudioTracks().length === 0) {
+				Janus.warn("No audio track");
+				return false;
+			}
+			config.myStream.getAudioTracks()[0].enabled = mute ? false : true;
+			return true;
+		}
+	}
+
+	function getBitrate(handleId) {
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle || !pluginHandle.webrtcStuff) {
+			Janus.warn("Invalid handle");
+			return "Invalid handle";
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(!config.pc)
+			return "Invalid PeerConnection";
+		// Start getting the bitrate, if getStats is supported
+		if(config.pc.getStats) {
+			if(!config.bitrate.timer) {
+				Janus.log("Starting bitrate timer (via getStats)");
+				config.bitrate.timer = setInterval(function() {
+					config.pc.getStats()
+						.then(function(stats) {
+							stats.forEach(function (res) {
+								if(!res)
+									return;
+								var inStats = false;
+								// Check if these are statistics on incoming media
+								if((res.mediaType === "video" || res.id.toLowerCase().indexOf("video") > -1) &&
+									res.type === "inbound-rtp" && res.id.indexOf("rtcp") < 0) {
+									// New stats
+									inStats = true;
+								} else if(res.type == 'ssrc' && res.bytesReceived &&
+									(res.googCodecName === "VP8" || res.googCodecName === "")) {
+									// Older Chromer versions
+									inStats = true;
+								}
+								// Parse stats now
+								if(inStats) {
+									config.bitrate.bsnow = res.bytesReceived;
+									config.bitrate.tsnow = res.timestamp;
+									if(config.bitrate.bsbefore === null || config.bitrate.tsbefore === null) {
+										// Skip this round
+										config.bitrate.bsbefore = config.bitrate.bsnow;
+										config.bitrate.tsbefore = config.bitrate.tsnow;
+									} else {
+										// Calculate bitrate
+										var timePassed = config.bitrate.tsnow - config.bitrate.tsbefore;
+										if(Janus.webRTCAdapter.browserDetails.browser === "safari")
+											timePassed = timePassed/1000;	// Apparently the timestamp is in microseconds, in Safari
+										var bitRate = Math.round((config.bitrate.bsnow - config.bitrate.bsbefore) * 8 / timePassed);
+										if(Janus.webRTCAdapter.browserDetails.browser === "safari")
+											bitRate = parseInt(bitRate/1000);
+										config.bitrate.value = bitRate + ' kbits/sec';
+										//~ Janus.log("Estimated bitrate is " + config.bitrate.value);
+										config.bitrate.bsbefore = config.bitrate.bsnow;
+										config.bitrate.tsbefore = config.bitrate.tsnow;
+									}
+								}
+							});
+						});
+				}, 1000);
+				return "0 kbits/sec";	// We don't have a bitrate value yet
+			}
+			return config.bitrate.value;
+		} else {
+			Janus.warn("Getting the video bitrate unsupported by browser");
+			return "Feature unsupported by browser";
+		}
+	}
+
+	function webrtcError(error) {
+		Janus.error("WebRTC error:", error);
+	}
+
+	function cleanupWebrtc(handleId, hangupRequest) {
+		Janus.log("Cleaning WebRTC stuff");
+		var pluginHandle = pluginHandles[handleId];
+		if(!pluginHandle) {
+			// Nothing to clean
+			return;
+		}
+		var config = pluginHandle.webrtcStuff;
+		if(config) {
+			if(hangupRequest === true) {
+				// Send a hangup request (we don't really care about the response)
+				var request = { "janus": "hangup", "transaction": Janus.randomString(12) };
+				if(pluginHandle.token)
+					request["token"] = pluginHandle.token;
+				if(apisecret)
+					request["apisecret"] = apisecret;
+				Janus.debug("Sending hangup request (handle=" + handleId + "):");
+				Janus.debug(request);
+				if(websockets) {
+					request["session_id"] = sessionId;
+					request["handle_id"] = handleId;
+					ws.send(JSON.stringify(request));
+				} else {
+					Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
+						verb: 'POST',
+						withCredentials: withCredentials,
+						body: request
+					});
+				}
+			}
+			// Cleanup stack
+			config.remoteStream = null;
+			if(config.volume) {
+				if(config.volume["local"] && config.volume["local"].timer)
+					clearInterval(config.volume["local"].timer);
+				if(config.volume["remote"] && config.volume["remote"].timer)
+					clearInterval(config.volume["remote"].timer);
+			}
+			config.volume = {};
+			if(config.bitrate.timer)
+				clearInterval(config.bitrate.timer);
+			config.bitrate.timer = null;
+			config.bitrate.bsnow = null;
+			config.bitrate.bsbefore = null;
+			config.bitrate.tsnow = null;
+			config.bitrate.tsbefore = null;
+			config.bitrate.value = null;
+			try {
+				// Try a MediaStreamTrack.stop() for each track
+				if(!config.streamExternal && config.myStream) {
+					Janus.log("Stopping local stream tracks");
+					var tracks = config.myStream.getTracks();
+					for(var mst of tracks) {
+						Janus.log(mst);
+						if(mst)
+							mst.stop();
+					}
+				}
+			} catch(e) {
+				// Do nothing if this fails
+			}
+			config.streamExternal = false;
+			config.myStream = null;
+			// Close PeerConnection
+			try {
+				config.pc.close();
+			} catch(e) {
+				// Do nothing
+			}
+			config.pc = null;
+			config.candidates = null;
+			config.mySdp = null;
+			config.remoteSdp = null;
+			config.iceDone = false;
+			config.dataChannel = {};
+			config.dtmfSender = null;
+		}
+		pluginHandle.oncleanup();
+	}
+
+	// Helper method to munge an SDP to enable simulcasting (Chrome only)
+	function mungeSdpForSimulcasting(sdp) {
+		// Let's munge the SDP to add the attributes for enabling simulcasting
+		// (based on https://gist.github.com/ggarber/a19b4c33510028b9c657)
+		var lines = sdp.split("\r\n");
+		var video = false;
+		var ssrc = [ -1 ], ssrc_fid = [ -1 ];
+		var cname = null, msid = null, mslabel = null, label = null;
+		var insertAt = -1;
+		for(var i=0; i<lines.length; i++) {
+			var mline = lines[i].match(/m=(\w+) */);
+			if(mline) {
+				var medium = mline[1];
+				if(medium === "video") {
+					// New video m-line: make sure it's the first one
+					if(ssrc[0] < 0) {
+						video = true;
+					} else {
+						// We're done, let's add the new attributes here
+						insertAt = i;
+						break;
+					}
+				} else {
+					// New non-video m-line: do we have what we were looking for?
+					if(ssrc[0] > -1) {
+						// We're done, let's add the new attributes here
+						insertAt = i;
+						break;
+					}
+				}
+				continue;
+			}
+			if(!video)
+				continue;
+			var fid = lines[i].match(/a=ssrc-group:FID (\d+) (\d+)/);
+			if(fid) {
+				ssrc[0] = fid[1];
+				ssrc_fid[0] = fid[2];
+				lines.splice(i, 1); i--;
+				continue;
+			}
+			if(ssrc[0]) {
+				var match = lines[i].match('a=ssrc:' + ssrc[0] + ' cname:(.+)')
+				if(match) {
+					cname = match[1];
+				}
+				match = lines[i].match('a=ssrc:' + ssrc[0] + ' msid:(.+)')
+				if(match) {
+					msid = match[1];
+				}
+				match = lines[i].match('a=ssrc:' + ssrc[0] + ' mslabel:(.+)')
+				if(match) {
+					mslabel = match[1];
+				}
+				match = lines[i].match('a=ssrc:' + ssrc[0] + ' label:(.+)')
+				if(match) {
+					label = match[1];
+				}
+				if(lines[i].indexOf('a=ssrc:' + ssrc_fid[0]) === 0) {
+					lines.splice(i, 1); i--;
+					continue;
+				}
+				if(lines[i].indexOf('a=ssrc:' + ssrc[0]) === 0) {
+					lines.splice(i, 1); i--;
+					continue;
+				}
+			}
+			if(lines[i].length == 0) {
+				lines.splice(i, 1); i--;
+				continue;
+			}
+		}
+		if(ssrc[0] < 0) {
+			// Couldn't find a FID attribute, let's just take the first video SSRC we find
+			insertAt = -1;
+			video = false;
+			for(var i=0; i<lines.length; i++) {
+				var mline = lines[i].match(/m=(\w+) */);
+				if(mline) {
+					var medium = mline[1];
+					if(medium === "video") {
+						// New video m-line: make sure it's the first one
+						if(ssrc[0] < 0) {
+							video = true;
+						} else {
+							// We're done, let's add the new attributes here
+							insertAt = i;
+							break;
+						}
+					} else {
+						// New non-video m-line: do we have what we were looking for?
+						if(ssrc[0] > -1) {
+							// We're done, let's add the new attributes here
+							insertAt = i;
+							break;
+						}
+					}
+					continue;
+				}
+				if(!video)
+					continue;
+				if(ssrc[0] < 0) {
+					var value = lines[i].match(/a=ssrc:(\d+)/);
+					if(value) {
+						ssrc[0] = value[1];
+						lines.splice(i, 1); i--;
+						continue;
+					}
+				} else {
+					var match = lines[i].match('a=ssrc:' + ssrc[0] + ' cname:(.+)')
+					if(match) {
+						cname = match[1];
+					}
+					match = lines[i].match('a=ssrc:' + ssrc[0] + ' msid:(.+)')
+					if(match) {
+						msid = match[1];
+					}
+					match = lines[i].match('a=ssrc:' + ssrc[0] + ' mslabel:(.+)')
+					if(match) {
+						mslabel = match[1];
+					}
+					match = lines[i].match('a=ssrc:' + ssrc[0] + ' label:(.+)')
+					if(match) {
+						label = match[1];
+					}
+					if(lines[i].indexOf('a=ssrc:' + ssrc_fid[0]) === 0) {
+						lines.splice(i, 1); i--;
+						continue;
+					}
+					if(lines[i].indexOf('a=ssrc:' + ssrc[0]) === 0) {
+						lines.splice(i, 1); i--;
+						continue;
+					}
+				}
+				if(lines[i].length == 0) {
+					lines.splice(i, 1); i--;
+					continue;
+				}
+			}
+		}
+		if(ssrc[0] < 0) {
+			// Still nothing, let's just return the SDP we were asked to munge
+			Janus.warn("Couldn't find the video SSRC, simulcasting NOT enabled");
+			return sdp;
+		}
+		if(insertAt < 0) {
+			// Append at the end
+			insertAt = lines.length;
+		}
+		// Generate a couple of SSRCs (for retransmissions too)
+		// Note: should we check if there are conflicts, here?
+		ssrc[1] = Math.floor(Math.random()*0xFFFFFFFF);
+		ssrc[2] = Math.floor(Math.random()*0xFFFFFFFF);
+		ssrc_fid[1] = Math.floor(Math.random()*0xFFFFFFFF);
+		ssrc_fid[2] = Math.floor(Math.random()*0xFFFFFFFF);
+		// Add attributes to the SDP
+		for(var i=0; i<ssrc.length; i++) {
+			if(cname) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc[i] + ' cname:' + cname);
+				insertAt++;
+			}
+			if(msid) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc[i] + ' msid:' + msid);
+				insertAt++;
+			}
+			if(mslabel) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc[i] + ' mslabel:' + mslabel);
+				insertAt++;
+			}
+			if(label) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc[i] + ' label:' + label);
+				insertAt++;
+			}
+			// Add the same info for the retransmission SSRC
+			if(cname) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc_fid[i] + ' cname:' + cname);
+				insertAt++;
+			}
+			if(msid) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc_fid[i] + ' msid:' + msid);
+				insertAt++;
+			}
+			if(mslabel) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc_fid[i] + ' mslabel:' + mslabel);
+				insertAt++;
+			}
+			if(label) {
+				lines.splice(insertAt, 0, 'a=ssrc:' + ssrc_fid[i] + ' label:' + label);
+				insertAt++;
+			}
+		}
+		lines.splice(insertAt, 0, 'a=ssrc-group:FID ' + ssrc[2] + ' ' + ssrc_fid[2]);
+		lines.splice(insertAt, 0, 'a=ssrc-group:FID ' + ssrc[1] + ' ' + ssrc_fid[1]);
+		lines.splice(insertAt, 0, 'a=ssrc-group:FID ' + ssrc[0] + ' ' + ssrc_fid[0]);
+		lines.splice(insertAt, 0, 'a=ssrc-group:SIM ' + ssrc[0] + ' ' + ssrc[1] + ' ' + ssrc[2]);
+		sdp = lines.join("\r\n");
+		if(!sdp.endsWith("\r\n"))
+			sdp += "\r\n";
+		return sdp;
+	}
+
+	// Helper methods to parse a media object
+	function isAudioSendEnabled(media) {
+		Janus.debug("isAudioSendEnabled:", media);
+		if(!media)
+			return true;	// Default
+		if(media.audio === false)
+			return false;	// Generic audio has precedence
+		if(media.audioSend === undefined || media.audioSend === null)
+			return true;	// Default
+		return (media.audioSend === true);
+	}
+
+	function isAudioSendRequired(media) {
+		Janus.debug("isAudioSendRequired:", media);
+		if(!media)
+			return false;	// Default
+		if(media.audio === false || media.audioSend === false)
+			return false;	// If we're not asking to capture audio, it's not required
+		if(media.failIfNoAudio === undefined || media.failIfNoAudio === null)
+			return false;	// Default
+		return (media.failIfNoAudio === true);
+	}
+
+	function isAudioRecvEnabled(media) {
+		Janus.debug("isAudioRecvEnabled:", media);
+		if(!media)
+			return true;	// Default
+		if(media.audio === false)
+			return false;	// Generic audio has precedence
+		if(media.audioRecv === undefined || media.audioRecv === null)
+			return true;	// Default
+		return (media.audioRecv === true);
+	}
+
+	function isVideoSendEnabled(media) {
+		Janus.debug("isVideoSendEnabled:", media);
+		if(!media)
+			return true;	// Default
+		if(media.video === false)
+			return false;	// Generic video has precedence
+		if(media.videoSend === undefined || media.videoSend === null)
+			return true;	// Default
+		return (media.videoSend === true);
+	}
+
+	function isVideoSendRequired(media) {
+		Janus.debug("isVideoSendRequired:", media);
+		if(!media)
+			return false;	// Default
+		if(media.video === false || media.videoSend === false)
+			return false;	// If we're not asking to capture video, it's not required
+		if(media.failIfNoVideo === undefined || media.failIfNoVideo === null)
+			return false;	// Default
+		return (media.failIfNoVideo === true);
+	}
+
+	function isVideoRecvEnabled(media) {
+		Janus.debug("isVideoRecvEnabled:", media);
+		if(!media)
+			return true;	// Default
+		if(media.video === false)
+			return false;	// Generic video has precedence
+		if(media.videoRecv === undefined || media.videoRecv === null)
+			return true;	// Default
+		return (media.videoRecv === true);
+	}
+
+	function isScreenSendEnabled(media) {
+		Janus.debug("isScreenSendEnabled:", media);
+		if (!media)
+			return false;
+		if (typeof media.video !== 'object' || typeof media.video.mandatory !== 'object')
+			return false;
+		var constraints = media.video.mandatory;
+		if (constraints.chromeMediaSource)
+			return constraints.chromeMediaSource === 'desktop' || constraints.chromeMediaSource === 'screen';
+		else if (constraints.mozMediaSource)
+			return constraints.mozMediaSource === 'window' || constraints.mozMediaSource === 'screen';
+		else if (constraints.mediaSource)
+			return constraints.mediaSource === 'window' || constraints.mediaSource === 'screen';
+		return false;
+	}
+
+	function isDataEnabled(media) {
+		Janus.debug("isDataEnabled:", media);
+		if(Janus.webRTCAdapter.browserDetails.browser === "edge") {
+			Janus.warn("Edge doesn't support data channels yet");
+			return false;
+		}
+		if(media === undefined || media === null)
+			return false;	// Default
+		return (media.data === true);
+	}
+
+	function isTrickleEnabled(trickle) {
+		Janus.debug("isTrickleEnabled:", trickle);
+		return (trickle === false) ? false : true;
+	}
+}
+module.exports = Janus;
diff --git a/src/main.js b/src/main.js
index 63eb05f..536c424 100644
--- a/src/main.js
+++ b/src/main.js
@@ -1,8 +1,14 @@
 import Vue from 'vue'
+import './plugins/axios'
+import JanusPlugin from "@/plugins/janus"
 import App from './App.vue'
+import vuetify from './plugins/vuetify';
 
-Vue.config.productionTip = false
 
+Vue.config.productionTip = false
+console.log("janus is installed", Vue.$janus)
 new Vue({
-  render: h => h(App),
+  vuetify,
+  JanusPlugin,
+  render: h => h(App)
 }).$mount('#app')
diff --git a/src/plugins/axios.js b/src/plugins/axios.js
new file mode 100644
index 0000000..753eee7
--- /dev/null
+++ b/src/plugins/axios.js
@@ -0,0 +1,62 @@
+"use strict";
+
+import Vue from 'vue';
+import axios from "axios";
+
+// Full config:  https://github.com/axios/axios#request-config
+// axios.defaults.baseURL = process.env.baseURL || process.env.apiUrl || '';
+// axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
+// axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+
+let config = {
+  // baseURL: process.env.baseURL || process.env.apiUrl || ""
+  // timeout: 60 * 1000, // Timeout
+  // withCredentials: true, // Check cross-site Access-Control
+};
+
+const _axios = axios.create(config);
+
+_axios.interceptors.request.use(
+  function(config) {
+    // Do something before request is sent
+    return config;
+  },
+  function(error) {
+    // Do something with request error
+    return Promise.reject(error);
+  }
+);
+
+// Add a response interceptor
+_axios.interceptors.response.use(
+  function(response) {
+    // Do something with response data
+    return response;
+  },
+  function(error) {
+    // Do something with response error
+    return Promise.reject(error);
+  }
+);
+
+// eslint-disable-next-line no-unused-vars
+Plugin.install = function(Vue, options) {
+  Vue.axios = _axios;
+  window.axios = _axios;
+  Object.defineProperties(Vue.prototype, {
+    axios: {
+      get() {
+        return _axios;
+      }
+    },
+    $axios: {
+      get() {
+        return _axios;
+      }
+    },
+  });
+};
+
+Vue.use(Plugin)
+
+export default Plugin;
diff --git a/src/plugins/janus.js b/src/plugins/janus.js
new file mode 100644
index 0000000..23ed19e
--- /dev/null
+++ b/src/plugins/janus.js
@@ -0,0 +1,21 @@
+"use strict";
+
+import Vue from 'vue'
+import Janus from "@/lib/janus"
+const _janus = Janus
+
+const JanusPlugin = {
+    // eslint-disable-next-line no-unused-vars
+    install(Vue, options) {
+        console.log('install call')
+        console.log(_janus)
+        _janus.init({debug: true, callback: function() {
+                Vue.prototype.$janus = _janus
+        }})
+    }
+}
+
+
+
+export default JanusPlugin;
+Vue.use(JanusPlugin)
diff --git a/src/plugins/vuetify.js b/src/plugins/vuetify.js
new file mode 100644
index 0000000..8a460c8
--- /dev/null
+++ b/src/plugins/vuetify.js
@@ -0,0 +1,23 @@
+import Vue from 'vue';
+import Vuetify from 'vuetify/lib';
+
+Vue.use(Vuetify);
+
+export default new Vuetify({
+  theme: {
+      options: {
+        customProperties: true,
+      },
+    themes: {
+      light: {
+        primary: '#ee44aa',
+        secondary: '#424242',
+        accent: '#82B1FF',
+        error: '#FF5252',
+        info: '#2196F3',
+        success: '#4CAF50',
+        warning: '#FFC107'
+      },
+    },
+  },
+});
diff --git a/vue.config.js b/vue.config.js
new file mode 100644
index 0000000..ef6e86b
--- /dev/null
+++ b/vue.config.js
@@ -0,0 +1,5 @@
+module.exports = {
+  "transpileDependencies": [
+    "vuetify"
+  ]
+}
\ No newline at end of file