.eslintrc.json

@@ -11,6 +11,7 @@
     "Atomics": "readonly",
     "SharedArrayBuffer": "readonly"
   },
+  "parser": "babel-eslint",
   "parserOptions": {
     "ecmaVersion": 2018,
     "sourceType": "module"

.gitignore

@@ -9,24 +9,54 @@ src/liowebrtc
 src/rtcpeerconnection
 src/signalbuddy
 src/yjs
-src/tiny-worker
-
-# Temporary test dump files
-dot-seq-add.json
-dot-seq-erase.json
-dot-seq-sync.json
-
-dot-par-add.json
-dot-par-erase.json
-dot-par-sync.json
-
-path-seq-add.json
-path-seq-erase.json
-path-seq-sync.json
-
-path-par-add.json
-path-par-erase.json
-path-par-sync.json
+src/drawing-crdt
+
+# Temporary benchmark dump files
+.dot-seq-add-packets.json
+.dot-seq-erase-packets.json
+.dot-seq-sync-packets.json
+.dot-seq-add-events.json
+.dot-seq-erase-events.json
+.dot-seq-sync-events.json
+
+.dot-par-add-packets.json
+.dot-par-erase-packets.json
+.dot-par-sync-packets.json
+.dot-par-add-events.json
+.dot-par-erase-events.json
+.dot-par-sync-events.json
+
+.path-seq-add-packets.json
+.path-seq-erase-packets.json
+.path-seq-sync-packets.json
+.path-seq-add-events.json
+.path-seq-erase-events.json
+.path-seq-sync-events.json
+
+.path-par-add-packets.json
+.path-par-erase-packets.json
+.path-par-sync-packets.json
+.path-par-add-events.json
+.path-par-erase-events.json
+.path-par-sync-events.json
+
+.dot-ver-add-packets.json
+.dot-ver-erase-packets.json
+.dot-ver-sync-packets.json
+.dot-ver-add-events.json
+.dot-ver-erase-events.json
+.dot-ver-sync-events.json
+
+.path-ver-add-packets.json
+.path-ver-erase-packets.json
+.path-ver-sync-packets.json
+.path-ver-add-events.json
+.path-ver-erase-events.json
+.path-ver-sync-events.json
+
+# Benchmark output files
+plots/*.tsv
+plots/*.pdf
 
 ### macOS ###
 # General
@@ -135,8 +165,10 @@ typings/
 .nuxt
 
 # react / gatsby (customised)
-public/js/app.js
-public/js/queue.js
+public/service-worker.js
+public/js
+public/benchmarks.html
+public/assets/fonts/font-awesome
 
 # vuepress build output
 .vuepress/dist

.gitlab-ci.yml

@@ -15,14 +15,14 @@ submodule_fetch:
   script:
     - chmod 600 .drawing-app-deploy.rsa
     - git submodule sync --recursive
-    - GIT_SSH_COMMAND='ssh -i .drawing-app-deploy.rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' git submodule update --init
+    - GIT_SSH_COMMAND='ssh -i '`pwd`'/.drawing-app-deploy.rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' git submodule update --init --recursive
   artifacts:
     paths:
       - src/liowebrtc
       - src/rtcpeerconnection
       - src/signalbuddy
       - src/yjs
-      - src/tiny-worker
+      - src/drawing-crdt/pkg
 
 npm_install_prod:
   stage: deps
@@ -33,11 +33,7 @@ npm_install_prod:
   artifacts:
     paths:
       - node_modules
-      - src/liowebrtc
-      - src/rtcpeerconnection
       - src/signalbuddy
-      - src/yjs
-      - src/tiny-worker
 
 npm_install:
   stage: deps
@@ -50,9 +46,9 @@ npm_install:
       - node_modules
       - src/liowebrtc
       - src/rtcpeerconnection
-      - src/signalbuddy
       - src/yjs
-      - src/tiny-worker
+      - src/drawing-crdt/pkg
+      - src/signalbuddy
 
 format_check:
   stage: check
@@ -74,6 +70,7 @@ build:
     - npm_install
   script:
     - npm run build
+    - gcc -E -P -traditional-cpp -o /dev/stdout -DFILES_TO_CACHE_LIST=`find public/ -type f "!" -iname service-worker.js -and "!" -name '.*' | cut -c6- | sed 's_._"_' | sed 's/$/",/' | sort | tr -d '\n'` - < src/service-worker.js | npx prettier --parser babel > public/service-worker.js
   artifacts:
     paths:
       - public/
@@ -110,5 +107,15 @@ benchmark:
   stage: benchmark
   dependencies:
     - npm_install
+  only:
+    - master
   script:
-    - npm run test-benchmark
+    - apt-get -y install gnuplot
+    - npm run build:bench
+    - cp __benchmarks__/benchmarks.html public/benchmarks.html
+    - npm run start-bg
+    - npm run benchmarks
+    - npm run plot
+  artifacts:
+    paths:
+      - plots/

.gitmodules

@@ -10,6 +10,6 @@
 [submodule "src/yjs"]
 	path = src/yjs
 	url = git@gitlab.doc.ic.ac.uk:sweng-group-15/yjs.git
-[submodule "src/tiny-worker"]
-	path = src/tiny-worker
-	url = git@gitlab.doc.ic.ac.uk:sweng-group-15/tiny-worker.git
+[submodule "src/drawing-crdt"]
+	path = src/drawing-crdt
+	url = git@gitlab.doc.ic.ac.uk:sweng-group-15/drawing-crdt.git

__benchmarks__/benchmarks.html

+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+  </head>
+  <body>
+    <script src="js/benchmarks.js"></script>
+  </body>
+</html>

__benchmarks__/benchmarks.js

+import { test, equal, ok, notOk } from "zora"
+
+import chalk from "chalk"
+
+import { connect } from "../src/room.js"
+
+import CRDT, { benchmark } from "../src/wasm-crdt.js"
+//import CRDT, { benchmark } from "../src/y-crdt.js"
+
+const { blocksize, eventsGC, syncStep1 } = benchmark
+
+import MockConnection, {
+  userID,
+  sendListener,
+  broadcastListener,
+  getEventListener,
+} from "../src/connection/MockConnection.js"
+
+import { handshake, dotDraw, dotErase, pathDraw, pathErase } from "./data.js"
+
+const remoteUserID = "392bf960-1d18-4482-bbbf-1c85e0132c9a"
+
+function createMessageReceivedEvent(
+  message,
+  channel = "crdt",
+  uid = remoteUserID,
+) {
+  return {
+    detail: {
+      uid,
+      channel,
+      message,
+    },
+  }
+}
+
+// Start: Adapted from https://github.com/jprichardson/buffer-json (MIT license)
+function stringify(value, space) {
+  return JSON.stringify(value, replacer, space)
+}
+
+function parse(text) {
+  return JSON.parse(text, reviver)
+}
+
+function replacer(key, value) {
+  if (value instanceof Uint8Array) {
+    return "base64:" + Buffer.from(value).toString("base64")
+  }
+  return value
+}
+
+function reviver(key, value) {
+  if (typeof value == "string" && value.startsWith("base64:")) {
+    return Uint8Array.from(Buffer.from(value.slice("base64:".length), "base64"))
+  }
+  return value
+}
+// End: Adapted from https://github.com/jprichardson/buffer-json (MIT license)
+
+let fs
+
+async function initFileSystem() {
+  fs = await new Promise((resolve, reject) =>
+    window.webkitRequestFileSystem(
+      window.TEMPORARY,
+      1024 * 1024 * 100,
+      resolve,
+      reject,
+    ),
+  )
+}
+
+async function dumpBSON(filename, data) {
+  await new Promise((resolve) => {
+    fs.root.getFile(
+      filename,
+      { create: false },
+      (fileEntry) => {
+        fileEntry.remove(resolve, console.error)
+      },
+      resolve,
+    )
+  })
+
+  await new Promise((resolve) => {
+    fs.root.getFile(
+      filename,
+      { create: true, exclusive: true },
+      (fileEntry) => {
+        fileEntry.createWriter((fileWriter) => {
+          fileWriter.onwriteend = resolve
+          fileWriter.onerror = console.error
+
+          const blob = new Blob([stringify(data)], { type: "text/plain" })
+
+          fileWriter.write(blob)
+        }, console.error)
+      },
+      console.error,
+    )
+  })
+}
+
+async function loadBSON(filename) {
+  return await new Promise((resolve) => {
+    fs.root.getFile(
+      filename,
+      {},
+      (fileEntry) => {
+        fileEntry.file((file) => {
+          const reader = new FileReader()
+
+          reader.onloadend = () => resolve(parse(reader.result))
+
+          reader.readAsText(file)
+        }, console.error)
+      },
+      console.error,
+    )
+  })
+}
+
+function printBenchmark(title, iterations, results) {
+  console.debug(`\n  ${title} (${iterations} iterations):\n`)
+
+  for (const title in results) {
+    const {
+      timeLoc,
+      encodeRAM,
+      packets,
+      size,
+      timeRem,
+      decodeRAM,
+      events,
+    } = results[title]
+    const synchronisation = title == "synchronisation"
+
+    console.debug(
+      chalk`    {yellow ⧗} {dim ${title}:} {yellow.inverse ${(
+        timeLoc /
+        (1e3 * (synchronisation ? 1 : iterations))
+      ).toFixed(3)}ms ${synchronisation ? "total" : "/ it"}} + {red.inverse ${(
+        encodeRAM /
+        (1024 * 1024)
+      ).toFixed(
+        3,
+      )}MB} => {dim ${packets} packet(s)} => {magenta.inverse ${size}B} => {yellow.inverse ${(
+        timeRem /
+        (1e3 * (synchronisation ? 1 : iterations))
+      ).toFixed(3)}ms ${synchronisation ? "total" : "/ it"}} + {red.inverse ${(
+        decodeRAM /
+        (1024 * 1024)
+      ).toFixed(3)}MB} => {dim ${events} event(s)}\n`,
+    )
+  }
+
+  console.debug(`\n`)
+}
+
+function writeBenchmarkHeader(filename, title, results) {
+  console.info(JSON.stringify({ filename, title, results }))
+}
+
+function appendBenchmark(filename, iterations, results) {
+  console.info(JSON.stringify({ filename, iterations, results }))
+}
+
+function captureHeapUsage() {
+  window.gc()
+
+  return window.performance.memory.usedJSHeapSize
+}
+
+function runBidirectionalBenchmark(
+  BENCHMARK,
+  FILENAME,
+  ITERATIONSLIST,
+  BLOCKSIZE,
+
+  addData,
+  eraseData,
+
+  addOnInitFrontend,
+  addBroadcastGroupTimeout,
+  addOnBroadcastGroup,
+  addPacketsFilename,
+
+  eraseOnInitFrontend,
+  eraseBroadcastGroupTimeout,
+  eraseOnBroadcastGroup,
+  erasePacketsFilename,
+
+  syncSendGroupTimeout,
+  syncOnSendGroup,
+  syncPacketsFilename,
+
+  addOnInitBackend,
+  addEventGroupTimeout,
+  addOnEventGroup,
+  addEventsCache,
+  addEventsFilename,
+
+  eraseOnInitBackend,
+  eraseEventGroupTimeout,
+  eraseOnEventGroup,
+  eraseEventsCache,
+  eraseEventsFilename,
+
+  syncEventGroupTimeout,
+  syncOnEventGroup,
+  syncEventsCache,
+  syncEventsFilename,
+) {
+  if (BENCHMARK && FILENAME) {
+    writeBenchmarkHeader(FILENAME, BENCHMARK, [
+      "addPath",
+      "extendErasureIntervals",
+      "synchronisation",
+    ])
+  }
+
+  return ITERATIONSLIST.reduce(
+    (promise, ITERATIONS) =>
+      promise.then(() => {
+        const pathIDs = []
+        let prevTime
+        let currTime
+
+        let connectRAM // eslint-disable-line no-unused-vars
+        let addLocTime = 0
+        let addPackets = []
+        let addSize = 0
+        let addRAM
+        let eraseLocTime = 0
+        let erasePackets = []
+        let eraseSize = 0
+        let eraseRAM
+        let syncLocTime
+        let syncPackets = []
+        let syncSize = 0
+        let syncRAM
+        let disconnectRAM // eslint-disable-line no-unused-vars
+
+        let connectUpdRAM // eslint-disable-line no-unused-vars
+        let addRemTime = 0
+        let addEvents = addEventsCache ? [] : 0
+        let addRemRAM
+        let eraseRemTime = 0
+        let eraseEvents = eraseEventsCache ? [] : 0
+        let eraseRemRAM
+        let disconnectUpdRAM // eslint-disable-line no-unused-vars
+
+        let connectSyncRAM // eslint-disable-line no-unused-vars
+        let syncRemTime = 0
+        let syncEvents = syncEventsCache ? [] : 0
+        let syncRemRAM
+        let disconnectSyncRAM // eslint-disable-line no-unused-vars
+
+        let timeout
+
+        let addEventListener = null
+        let eraseEventListener = null
+
+        let room = null
+        let updateRoom = null
+        let syncRoom = null
+
+        return (
+          // eslint-disable-next-line no-async-promise-executor
+          new Promise(async (resolve) => {
+            userID.uuid = "61a540d6-4522-48c7-a660-1ed501503cb7"
+
+            room = await connect("room", CRDT, MockConnection)
+            getEventListener(
+              "room",
+              "messageReceived",
+            )(createMessageReceivedEvent(handshake, "tw-ml"))
+
+            connectRAM = captureHeapUsage()
+
+            return resolve()
+          })
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  let broadcasts = 0
+
+                  broadcastListener.callback = (channel, message) => {
+                    currTime = window.performance.now()
+
+                    equal(channel, "crdt")
+                    ok(message instanceof Uint8Array)
+
+                    addPackets[addPackets.length - 1].push(message)
+                    addSize += message.length
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(() => {
+                      broadcasts += 1
+
+                      addLocTime += (currTime - prevTime) * 1e3
+
+                      prevTime = window.performance.now()
+
+                      addOnBroadcastGroup(
+                        room,
+                        addPackets,
+                        pathIDs,
+                        addData,
+                        ITERATIONS,
+                        broadcasts,
+                        resolve,
+                      )
+                    }, addBroadcastGroupTimeout)
+                  }
+
+                  prevTime = window.performance.now()
+
+                  addOnInitFrontend(
+                    room,
+                    addPackets,
+                    pathIDs,
+                    addData,
+                    ITERATIONS,
+                    BLOCKSIZE,
+                  )
+                }),
+            )
+            .then(async () => {
+              broadcastListener.callback = null
+
+              await dumpBSON(addPacketsFilename, addPackets)
+              addPackets = null
+
+              addRAM = captureHeapUsage()
+            })
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  let broadcasts = 0
+
+                  broadcastListener.callback = (channel, message) => {
+                    currTime = window.performance.now()
+
+                    equal(channel, "crdt")
+                    ok(message instanceof Uint8Array)
+
+                    erasePackets[erasePackets.length - 1].push(message)
+                    eraseSize += message.length
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(() => {
+                      broadcasts += 1
+
+                      eraseLocTime += (currTime - prevTime) * 1e3
+
+                      prevTime = window.performance.now()
+
+                      eraseOnBroadcastGroup(
+                        room,
+                        erasePackets,
+                        pathIDs,
+                        eraseData,
+                        ITERATIONS,
+                        broadcasts,
+                        resolve,
+                      )
+                    }, eraseBroadcastGroupTimeout)
+                  }
+
+                  prevTime = window.performance.now()
+
+                  eraseOnInitFrontend(
+                    room,
+                    erasePackets,
+                    pathIDs,
+                    eraseData,
+                    ITERATIONS,
+                    BLOCKSIZE,
+                  )
+                }),
+            )
+            .then(async () => {
+              broadcastListener.callback = null
+
+              await dumpBSON(erasePacketsFilename, erasePackets)
+              erasePackets = null
+
+              eraseRAM = captureHeapUsage()
+            })
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  sendListener.callback = (uid, channel, message) => {
+                    const currTime = window.performance.now()
+
+                    equal(uid, remoteUserID)
+                    equal(channel, "crdt")
+                    ok(message instanceof Uint8Array)
+
+                    syncLocTime = (currTime - prevTime) * 1e3
+
+                    syncPackets.push(message)
+
+                    syncSize += message.length
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(
+                      () => syncOnSendGroup(syncPackets, resolve),
+                      syncSendGroupTimeout,
+                    )
+                  }
+
+                  prevTime = window.performance.now()
+
+                  getEventListener(
+                    "room",
+                    "messageReceived",
+                  )(createMessageReceivedEvent(syncStep1))
+                }),
+            )
+            .then(async () => {
+              sendListener.callback = null
+
+              await dumpBSON(syncPacketsFilename, syncPackets)
+              syncPackets = null
+
+              syncRAM = captureHeapUsage()
+
+              room.disconnect()
+              room = null
+
+              disconnectRAM = captureHeapUsage()
+            })
+            .then(
+              () =>
+                // eslint-disable-next-line no-async-promise-executor
+                new Promise(async (resolve) => {
+                  userID.uuid = "5c9e550b-3de8-4a32-80e1-80c08c19891a"
+
+                  updateRoom = await connect("update", CRDT, MockConnection)
+                  getEventListener(
+                    "update",
+                    "messageReceived",
+                  )(createMessageReceivedEvent(handshake, "tw-ml"))
+
+                  connectUpdRAM = captureHeapUsage()
+
+                  addPackets = await loadBSON(addPacketsFilename)
+
+                  return resolve()
+                }),
+            )
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  let broadcasts = 0
+
+                  let currTime
+
+                  const timeoutCallback = () => {
+                    broadcasts += 1
+
+                    addRemTime += (currTime - prevTime) * 1e3
+
+                    prevTime = window.performance.now()
+
+                    addOnEventGroup(
+                      addPackets,
+                      ITERATIONS,
+                      broadcasts,
+                      resolve,
+                      addEvents,
+                      pathIDs,
+                      addData,
+                    )
+                  }
+
+                  addEventListener = (event) => {
+                    currTime = window.performance.now()
+
+                    if (addEventsCache) {
+                      addEvents.push({ add: event })
+                    } else {
+                      addEvents += 1
+                    }
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(timeoutCallback, addEventGroupTimeout)
+                  }
+                  eraseEventListener = (event) => {
+                    currTime = window.performance.now()
+
+                    if (addEventsCache) {
+                      addEvents.push({ erase: event })
+                    } else {
+                      addEvents += 1
+                    }
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(timeoutCallback, addEventGroupTimeout)
+                  }
+
+                  updateRoom.addEventListener(
+                    "addOrUpdatePath",
+                    addEventListener,
+                  )
+                  updateRoom.addEventListener(
+                    "removedIntervalsChange",
+                    eraseEventListener,
+                  )
+
+                  prevTime = window.performance.now()
+
+                  addOnInitBackend(addPackets, BLOCKSIZE)
+                }),
+            )
+            .then(async () => {
+              updateRoom.removeEventListener(
+                "addOrUpdatePath",
+                addEventListener,
+              )
+              addEventListener = null
+
+              updateRoom.removeEventListener(
+                "removedIntervalsChange",
+                eraseEventListener,
+              )
+              eraseEventListener = null
+
+              addPackets = null
+
+              await dumpBSON(addEventsFilename, addEvents)
+              addEvents = null
+
+              addRemRAM = captureHeapUsage()
+
+              erasePackets = await loadBSON(erasePacketsFilename)
+            })
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  let broadcasts = 0
+
+                  let currTime
+
+                  const timeoutCallback = () => {
+                    broadcasts += 1
+
+                    eraseRemTime += (currTime - prevTime) * 1e3
+
+                    prevTime = window.performance.now()
+
+                    eraseOnEventGroup(
+                      erasePackets,
+                      ITERATIONS,
+                      broadcasts,
+                      resolve,
+                      eraseEvents,
+                      pathIDs,
+                      addData,
+                      eraseData,
+                    )
+                  }
+
+                  eraseEventListener = (event) => {
+                    currTime = window.performance.now()
+
+                    if (eraseEventsCache) {
+                      eraseEvents.push({ erase: event })
+                    } else {
+                      eraseEvents += 1
+                    }
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(
+                      timeoutCallback,
+                      eraseEventGroupTimeout,
+                    )
+                  }
+
+                  updateRoom.addEventListener(
+                    "removedIntervalsChange",
+                    eraseEventListener,
+                  )
+
+                  prevTime = window.performance.now()
+
+                  eraseOnInitBackend(erasePackets, BLOCKSIZE)
+                }),
+            )
+            .then(async () => {
+              updateRoom.removeEventListener(
+                "removedIntervalsChange",
+                eraseEventListener,
+              )
+              eraseEventListener = null
+
+              erasePackets = null
+
+              await dumpBSON(eraseEventsFilename, eraseEvents)
+              eraseEvents = null
+
+              eraseRemRAM = captureHeapUsage()
+
+              updateRoom.disconnect()
+              updateRoom = null
+
+              disconnectUpdRAM = captureHeapUsage()
+            })
+            .then(
+              () =>
+                // eslint-disable-next-line no-async-promise-executor
+                new Promise(async (resolve) => {
+                  userID.uuid = "a2108f84-3785-4696-8dd5-fb89b38d4f7f"
+
+                  syncRoom = await connect("sync", CRDT, MockConnection)
+                  getEventListener(
+                    "sync",
+                    "messageReceived",
+                  )(createMessageReceivedEvent(handshake, "tw-ml"))
+
+                  connectSyncRAM = captureHeapUsage()
+
+                  syncPackets = await loadBSON(syncPacketsFilename)
+
+                  return resolve()
+                }),
+            )
+            .then(
+              () =>
+                new Promise((resolve) => {
+                  addEventListener = (event) => {
+                    const currTime = window.performance.now()
+
+                    syncRemTime = (currTime - prevTime) * 1e3
+
+                    if (syncEventsCache) {
+                      syncEvents.push({ add: event })
+                    } else {
+                      syncEvents += 1
+
+                      if (syncEvents % eventsGC == 1) {
+                        captureHeapUsage()
+                      }
+                    }
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(
+                      () =>
+                        syncOnEventGroup(
+                          resolve,
+                          syncEvents,
+                          pathIDs,
+                          addData,
+                          eraseData,
+                        ),
+                      syncEventGroupTimeout,
+                    )
+                  }
+                  eraseEventListener = (event) => {
+                    const currTime = window.performance.now()
+
+                    syncRemTime = (currTime - prevTime) * 1e3
+
+                    if (syncEventsCache) {
+                      syncEvents.push({ erase: event })
+                    } else {
+                      syncEvents += 1
+
+                      if (syncEvents % eventsGC == 1) {
+                        captureHeapUsage()
+                      }
+                    }
+
+                    clearTimeout(timeout)
+                    timeout = setTimeout(
+                      () =>
+                        syncOnEventGroup(
+                          resolve,
+                          syncEvents,
+                          pathIDs,
+                          addData,
+                          eraseData,
+                        ),
+                      syncEventGroupTimeout,
+                    )
+                  }
+
+                  syncRoom.addEventListener("addOrUpdatePath", addEventListener)
+                  syncRoom.addEventListener(
+                    "removedIntervalsChange",
+                    eraseEventListener,
+                  )
+                  prevTime = window.performance.now()
+
+                  for (const syncPacket of syncPackets) {
+                    getEventListener(
+                      "sync",
+                      "messageReceived",
+                    )(createMessageReceivedEvent(syncPacket))
+                  }
+
+                  syncPackets = null
+
+                  captureHeapUsage()
+                }),
+            )
+            .then(async () => {
+              syncRoom.removeEventListener("addOrUpdatePath", addEventListener)
+              addEventListener = null
+
+              syncRoom.removeEventListener(
+                "removedIntervalsChange",
+                eraseEventListener,
+              )
+              eraseEventListener = null
+
+              syncPackets = null
+
+              await dumpBSON(syncEventsFilename, syncEvents)
+              syncEvents = null
+
+              syncRemRAM = captureHeapUsage()
+
+              syncRoom.disconnect()
+              syncRoom = null
+
+              disconnectSyncRAM = captureHeapUsage()
+            })
+            .then(async () => {
+              if (!BENCHMARK) {
+                return
+              }
+
+              addPackets = (await loadBSON(addPacketsFilename)).reduce(
+                (sum, packets) => sum + packets.length,
+                0,
+              )
+              erasePackets = (await loadBSON(erasePacketsFilename)).reduce(
+                (sum, packets) => sum + packets.length,
+                0,
+              )
+              syncPackets = (await loadBSON(syncPacketsFilename)).length
+
+              addEvents = await loadBSON(addEventsFilename)
+              addEvents = addEventsCache ? addEvents.length : addEvents
+
+              eraseEvents = await loadBSON(eraseEventsFilename)
+              eraseEvents = eraseEventsCache ? eraseEvents.length : eraseEvents
+
+              syncEvents = await loadBSON(syncEventsFilename)
+              syncEvents = syncEventsCache ? syncEvents.length : syncEvents
+
+              const results = {
+                addPath: {
+                  timeLoc: addLocTime,
+                  encodeRAM: addRAM,
+                  packets: addPackets,
+                  size: addSize,
+                  timeRem: addRemTime,
+                  decodeRAM: addRemRAM,
+                  events: addEvents,
+                },
+                extendErasureIntervals: {
+                  timeLoc: eraseLocTime,
+                  encodeRAM: eraseRAM,
+                  packets: erasePackets,
+                  size: eraseSize,
+                  timeRem: eraseRemTime,
+                  decodeRAM: eraseRemRAM,
+                  events: eraseEvents,
+                },
+                synchronisation: {
+                  timeLoc: syncLocTime,
+                  encodeRAM: syncRAM,
+                  packets: syncPackets,
+                  size: syncSize,
+                  timeRem: syncRemTime,
+                  decodeRAM: syncRemRAM,
+                  events: syncEvents,
+                },
+              }
+
+              printBenchmark(BENCHMARK, ITERATIONS, results)
+              appendBenchmark(FILENAME, ITERATIONS, results)
+            })
+        )
+      }),
+    Promise.resolve(),
+  )
+}
+
+function addOnInitFrontendSequential(
+  room,
+  addPackets,
+  pathIDs,
+  addData,
+  ITERATIONS, // eslint-disable-line no-unused-vars
+  BLOCKSIZE, // eslint-disable-line no-unused-vars
+) {
+  addPackets.push([])
+
+  const drawPathID = room.addPath(addData[0])
+  pathIDs.push(drawPathID)
+
+  for (let i = 1; i < addData.length; i++) {
+    room.extendPath(drawPathID, addData[i])
+  }
+
+  room.endPath(drawPathID)
+}
+
+function addOnBroadcastGroupSequential(
+  room,
+  addPackets,
+  pathIDs,
+  addData,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+) {
+  if (broadcasts < ITERATIONS) {
+    addPackets.push([])
+
+    const drawPathID = room.addPath(addData[0])
+    pathIDs.push(drawPathID)
+
+    for (let i = 1; i < addData.length; i++) {
+      room.extendPath(drawPathID, addData[i])
+    }
+
+    room.endPath(drawPathID)
+  } else {
+    resolve()
+  }
+}
+
+function eraseOnInitFrontendSequential(
+  room,
+  erasePackets,
+  pathIDs,
+  eraseData,
+  ITERATIONS, // eslint-disable-line no-unused-vars
+  BLOCKSIZE, // eslint-disable-line no-unused-vars
+) {
+  erasePackets.push([])
+
+  const erasePathID = pathIDs[0]
+
+  for (let i = 0; i < eraseData.length; i++) {
+    room.extendErasureIntervals(erasePathID, eraseData[i][0], eraseData[i][1])
+  }
+}
+
+function eraseOnBroadcastGroupSequential(
+  room,
+  erasePackets,
+  pathIDs,
+  eraseData,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+) {
+  if (broadcasts < ITERATIONS) {
+    erasePackets.push([])
+
+    const erasePathID = pathIDs[broadcasts]
+
+    for (let i = 0; i < eraseData.length; i++) {
+      room.extendErasureIntervals(erasePathID, eraseData[i][0], eraseData[i][1])
+    }
+  } else {
+    resolve()
+  }
+}
+
+function syncOnSendGroup(syncPackets, resolve) {
+  resolve()
+}
+
+function addOnInitBackendSequential(
+  addPackets,
+  BLOCKSIZE, // eslint-disable-line no-unused-vars
+) {
+  for (const packet of addPackets[0]) {
+    getEventListener(
+      "update",
+      "messageReceived",
+    )(createMessageReceivedEvent(packet))
+  }
+}
+
+function addOnEventGroupSequential(
+  addPackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  addEvents, // eslint-disable-line no-unused-vars
+  pathIDs, // eslint-disable-line no-unused-vars
+  addData, // eslint-disable-line no-unused-vars
+) {
+  if (broadcasts >= ITERATIONS) {
+    return resolve()
+  }
+
+  for (const packet of addPackets[broadcasts]) {
+    getEventListener(
+      "update",
+      "messageReceived",
+    )(createMessageReceivedEvent(packet))
+  }
+}
+
+function eraseOnInitBackendSequential(
+  erasePackets,
+  BLOCKSIZE, // eslint-disable-line no-unused-vars
+) {
+  for (const packet of erasePackets[0]) {
+    getEventListener(
+      "update",
+      "messageReceived",
+    )(createMessageReceivedEvent(packet))
+  }
+}
+
+function eraseOnEventGroupSequential(
+  erasePackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  eraseEvents, // eslint-disable-line no-unused-vars
+  pathIDs, // eslint-disable-line no-unused-vars
+  addData, // eslint-disable-line no-unused-vars
+  eraseData, // eslint-disable-line no-unused-vars
+) {
+  if (broadcasts >= ITERATIONS) {
+    return resolve()
+  }
+
+  for (const packet of erasePackets[broadcasts]) {
+    getEventListener(
+      "update",
+      "messageReceived",
+    )(createMessageReceivedEvent(packet))
+  }
+}
+
+function syncOnEventGroup(
+  resolve,
+  syncEvents, // eslint-disable-line no-unused-vars
+  pathIDs, // eslint-disable-line no-unused-vars
+  addData, // eslint-disable-line no-unused-vars
+  eraseData, // eslint-disable-line no-unused-vars
+) {
+  resolve()
+}
+
+function addOnInitFrontendParallel(
+  room,
+  addPackets,
+  pathIDs,
+  addData,
+  ITERATIONS,
+  BLOCKSIZE,
+) {
+  addPackets.push([])
+
+  // Necessary to allow yjs to execute transactions (majority of processing time)
+  function addPath(sj) {
+    if (sj >= ITERATIONS) return
+
+    for (let j = sj; j < Math.min(sj + BLOCKSIZE, ITERATIONS); j++) {
+      const drawPathID = room.addPath(addData[0])
+      pathIDs.push(drawPathID)
+
+      for (let i = 1; i < addData.length; i++) {
+        room.extendPath(drawPathID, addData[i])
+      }
+
+      room.endPath(drawPathID)
+    }
+
+    captureHeapUsage()
+
+    setTimeout(addPath, 0, sj + BLOCKSIZE)
+  }
+
+  addPath(0)
+}
+
+function addOnBroadcastGroupParallel(
+  room,
+  addPackets,
+  pathIDs,
+  addData,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+) {
+  resolve()
+}
+
+function eraseOnInitFrontendParallel(
+  room,
+  erasePackets,
+  pathIDs,
+  eraseData,
+  ITERATIONS,
+  BLOCKSIZE,
+) {
+  erasePackets.push([])
+
+  // Necessary to allow yjs to execute transactions (majority of processing time)
+  function erasePath(sj) {
+    if (sj >= ITERATIONS) return
+
+    for (let j = sj; j < Math.min(sj + BLOCKSIZE, ITERATIONS); j++) {
+      const erasePathID = pathIDs[j]
+
+      for (let i = 0; i < eraseData.length; i++) {
+        room.extendErasureIntervals(
+          erasePathID,
+          eraseData[i][0],
+          eraseData[i][1],
+        )
+      }
+    }
+
+    captureHeapUsage()
+
+    setTimeout(erasePath, 0, sj + BLOCKSIZE)
+  }
+
+  erasePath(0)
+}
+
+function eraseOnBroadcastGroupParallel(
+  room,
+  erasePackets,
+  pathIDs,
+  eraseData,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+) {
+  resolve()
+}
+
+function addOnInitBackendParallel(addPackets, BLOCKSIZE) {
+  const packets = addPackets[0]
+
+  function addPath(sj) {
+    if (sj >= packets.length) return
+
+    for (let j = sj; j < Math.min(sj + BLOCKSIZE, packets.length); j++) {
+      getEventListener(
+        "update",
+        "messageReceived",
+      )(createMessageReceivedEvent(packets[j]))
+    }
+
+    captureHeapUsage()
+
+    setTimeout(addPath, 0, sj + BLOCKSIZE)
+  }
+
+  addPath(0)
+}
+
+function addOnEventGroupParallel(
+  addPackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  addEvents, // eslint-disable-line no-unused-vars
+  pathIDs, // eslint-disable-line no-unused-vars
+  addData, // eslint-disable-line no-unused-vars
+) {
+  resolve()
+}
+
+function eraseOnInitBackendParallel(erasePackets, BLOCKSIZE) {
+  const packets = erasePackets[0]
+
+  function erasePath(sj) {
+    if (sj >= packets.length) return
+
+    for (let j = sj; j < Math.min(sj + BLOCKSIZE, packets.length); j++) {
+      getEventListener(
+        "update",
+        "messageReceived",
+      )(createMessageReceivedEvent(packets[j]))
+    }
+
+    captureHeapUsage()
+
+    setTimeout(erasePath, 0, sj + BLOCKSIZE)
+  }
+
+  erasePath(0)
+}
+
+function eraseOnEventGroupParallel(
+  erasePackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  eraseEvents, // eslint-disable-line no-unused-vars
+  pathIDs, // eslint-disable-line no-unused-vars
+  addData, // eslint-disable-line no-unused-vars
+  eraseData, // eslint-disable-line no-unused-vars
+) {
+  resolve()
+}
+
+function addOnEventGroupVerify(
+  addPackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  addEvents,
+  pathIDs,
+  addData,
+) {
+  const updatePaths = {}
+  const updateIntervals = {}
+
+  for (const event of addEvents) {
+    equal(!event.add + !event.erase, 1)
+
+    if (event.add) {
+      const {
+        detail: { id, points },
+      } = event.add
+
+      updatePaths[id] = points
+    } else if (event.erase) {
+      const {
+        detail: { id, intervals },
+      } = event.erase
+
+      updateIntervals[id] = intervals
+    }
+  }
+
+  equal(updatePaths, { [pathIDs[0]]: addData })
+  equal(updateIntervals, { [pathIDs[0]]: {} })
+
+  resolve()
+}
+
+function eraseOnEventGroupVerify(
+  erasePackets,
+  ITERATIONS,
+  broadcasts,
+  resolve,
+  eraseEvents,
+  pathIDs,
+  addData,
+  eraseData, // eslint-disable-line no-unused-vars
+) {
+  const updateIntervals = {}
+
+  for (const event of eraseEvents) {
+    ok(!event.add)
+    notOk(!event.erase)
+
+    const {
+      detail: { id, intervals },
+    } = event.erase
+
+    updateIntervals[id] = intervals
+  }
+
+  equal(updateIntervals, {
+    [pathIDs[0]]: Object.assign(
+      {},
+      new Array(addData.length).fill([[0, 0 + (addData.length > 1)]]),
+    ),
+  })
+
+  resolve()
+}
+
+function syncOnEventGroupVerify(
+  resolve,
+  syncEvents,
+  pathIDs,
+  addData,
+  eraseData, // eslint-disable-line no-unused-vars
+) {
+  const syncPaths = {}
+  const syncIntervals = {}
+
+  for (const event of syncEvents) {
+    equal(!event.add + !event.erase, 1)
+
+    if (event.add) {
+      const {
+        detail: { id, points },
+      } = event.add
+
+      syncPaths[id] = points
+    } else if (event.erase) {
+      const {
+        detail: { id, intervals },
+      } = event.erase
+
+      syncIntervals[id] = intervals
+    }
+  }
+
+  equal(syncPaths, { [pathIDs[0]]: addData })
+  equal(syncIntervals, {
+    [pathIDs[0]]: Object.assign(
+      {},
+      new Array(addData.length).fill([[0, 0 + (addData.length > 1)]]),
+    ),
+  })
+
+  resolve()
+}
+
+test("benchmark", async (t) => {
+  await initFileSystem()
+
+  const ITERATIONSLIST = [10, 25, 50, 75, 100, 250, 500]
+  const BLOCKSIZE = blocksize
+
+  await t.test("communicates a dot draw and erase update", async (/*t*/) => {
+    return runBidirectionalBenchmark(
+      null /* BENCHMARK */,
+      null /* FILENAME */,
+      [1] /* ITERATIONSLIST */,
+      BLOCKSIZE /* BLOCKSIZE */,
+      dotDraw /* addData */,
+      dotErase /* eraseData */,
+      addOnInitFrontendSequential /* addOnInitFrontend */,
+      1000 /* addBroadcastGroupTimeout */,
+      addOnBroadcastGroupParallel /* addOnBroadcastGroup */,
+      ".dot-ver-add-packets.json" /* addPacketsFilename */,
+      eraseOnInitFrontendSequential /* eraseOnInitFrontend */,
+      1000 /* eraseBroadcastGroupTimeout */,
+      eraseOnBroadcastGroupParallel /* eraseOnBroadcastGroup */,
+      ".dot-ver-erase-packets.json" /* erasePacketsFilename */,
+      1000 /* syncSendGroupTimeout */,
+      syncOnSendGroup /* syncOnSendGroup */,
+      ".dot-ver-sync-packets.json" /* syncPacketsFilename */,
+      addOnInitBackendSequential /* addOnInitBackend */,
+      1000 /* addEventGroupTimeout */,
+      addOnEventGroupVerify /* addOnEventGroup */,
+      true /* addEventsCache */,
+      ".dot-ver-add-events.json" /* addEventsFilename */,
+      eraseOnInitBackendSequential /* eraseOnInitBackend */,
+      1000 /* eraseEventGroupTimeout */,
+      eraseOnEventGroupVerify /* eraseOnEventGroupTimeout */,
+      true /* eraseEventsCache */,
+      ".dot-ver-erase-events.json" /* eraseEventsFilename */,
+      1000 /* syncEventGroupTimeout */,
+      syncOnEventGroupVerify /* syncOnEventGroup */,
+      true /* syncEventsCache */,
+      ".dot-ver-sync-events.json" /* syncEventsFilename */,
+    )
+  })
+
+  await t.test(
+    "benchmarks a dot draw and erase update sequentially",
+    async (/*t*/) => {
+      return runBidirectionalBenchmark(
+        "dot draw and erase [sequential]" /* BENCHMARK */,
+        "plots/dot-seq-benchmark.tsv" /* FILENAME */,
+        ITERATIONSLIST /* ITERATIONSLIST */,
+        BLOCKSIZE /* BLOCKSIZE */,
+        dotDraw /* addData */,
+        dotErase /* eraseData */,
+        addOnInitFrontendSequential /* addOnInitFrontend */,
+        100 /* addBroadcastGroupTimeout */,
+        addOnBroadcastGroupSequential /* addOnBroadcastGroup */,
+        ".dot-seq-add-packets.json" /* addPacketsFilename */,
+        eraseOnInitFrontendSequential /* eraseOnInitFrontend */,
+        100 /* eraseBroadcastGroupTimeout */,
+        eraseOnBroadcastGroupSequential /* eraseOnBroadcastGroup */,
+        ".dot-seq-erase-packets.json" /* erasePacketsFilename */,
+        1000 /* syncSendGroupTimeout */,
+        syncOnSendGroup /* syncOnSendGroup */,
+        ".dot-seq-sync-packets.json" /* syncPacketsFilename */,
+        addOnInitBackendSequential /* addOnInitBackend */,
+        100 /* addEventGroupTimeout */,
+        addOnEventGroupSequential /* addOnEventGroup */,
+        false /* addEventsCache */,
+        ".dot-seq-add-events.json" /* addEventsFilename */,
+        eraseOnInitBackendSequential /* eraseOnInitBackend */,
+        100 /* eraseEventGroupTimeout */,
+        eraseOnEventGroupSequential /* eraseOnEventGroupTimeout */,
+        false /* eraseEventsCache */,
+        ".dot-seq-erase-events.json" /* eraseEventsFilename */,
+        1000 /* syncEventGroupTimeout */,
+        syncOnEventGroup /* syncOnEventGroup */,
+        false /* syncEventsCache */,
+        ".dot-seq-sync-events.json" /* syncEventsFilename */,
+      )
+    },
+  )
+
+  await t.test(
+    "benchmarks a dot draw and erase update in parallel",
+    async (/*t*/) => {
+      return runBidirectionalBenchmark(
+        "dot draw and erase [parallel]" /* BENCHMARK */,
+        "plots/dot-par-benchmark.tsv" /* FILENAME */,
+        ITERATIONSLIST /* ITERATIONSLIST */,
+        BLOCKSIZE /* BLOCKSIZE */,
+        dotDraw /* addData */,
+        dotErase /* eraseData */,
+        addOnInitFrontendParallel /* addOnInitFrontend */,
+        1000 /* addBroadcastGroupTimeout */,
+        addOnBroadcastGroupParallel /* addOnBroadcastGroup */,
+        ".dot-par-add-packets.json" /* addPacketsFilename */,
+        eraseOnInitFrontendParallel /* eraseOnInitFrontend */,
+        1000 /* eraseBroadcastGroupTimeout */,
+        eraseOnBroadcastGroupParallel /* eraseOnBroadcastGroup */,
+        ".dot-par-erase-packets.json" /* erasePacketsFilename */,
+        1000 /* syncSendGroupTimeout */,
+        syncOnSendGroup /* syncOnSendGroup */,
+        ".dot-par-sync-packets.json" /* syncPacketsFilename */,
+        addOnInitBackendParallel /* addOnInitBackend */,
+        1000 /* addEventGroupTimeout */,
+        addOnEventGroupParallel /* addOnEventGroup */,
+        false /* addEventsCache */,
+        ".dot-par-add-events.json" /* addEventsFilename */,
+        eraseOnInitBackendParallel /* eraseOnInitBackend */,
+        1000 /* eraseEventGroupTimeout */,
+        eraseOnEventGroupParallel /* eraseOnEventGroupTimeout */,
+        false /* eraseEventsCache */,
+        ".dot-par-erase-events.json" /* eraseEventsFilename */,
+        1000 /* syncEventGroupTimeout */,
+        syncOnEventGroup /* syncOnEventGroup */,
+        false /* syncEventsCache */,
+        ".dot-par-sync-events.json" /* syncEventsFilename */,
+      )
+    },
+  )
+
+  await t.test("communicates a path draw and erase update", async (/*t*/) => {
+    return runBidirectionalBenchmark(
+      null /* BENCHMARK */,
+      null /* FILENAME */,
+      [1] /* ITERATIONSLIST */,
+      BLOCKSIZE /* BLOCKSIZE */,
+      pathDraw /* addData */,
+      pathErase /* eraseData */,
+      addOnInitFrontendSequential /* addOnInitFrontend */,
+      1000 /* addBroadcastGroupTimeout */,
+      addOnBroadcastGroupParallel /* addOnBroadcastGroup */,
+      ".path-ver-add-packets.json" /* addPacketsFilename */,
+      eraseOnInitFrontendSequential /* eraseOnInitFrontend */,
+      1000 /* eraseBroadcastGroupTimeout */,
+      eraseOnBroadcastGroupParallel /* eraseOnBroadcastGroup */,
+      ".path-ver-erase-packets.json" /* erasePacketsFilename */,
+      1000 /* syncSendGroupTimeout */,
+      syncOnSendGroup /* syncOnSendGroup */,
+      ".path-ver-sync-packets.json" /* syncPacketsFilename */,
+      addOnInitBackendSequential /* addOnInitBackend */,
+      1000 /* addEventGroupTimeout */,
+      addOnEventGroupVerify /* addOnEventGroup */,
+      true /* addEventsCache */,
+      ".path-ver-add-events.json" /* addEventsFilename */,
+      eraseOnInitBackendSequential /* eraseOnInitBackend */,
+      1000 /* eraseEventGroupTimeout */,
+      eraseOnEventGroupVerify /* eraseOnEventGroupTimeout */,
+      true /* eraseEventsCache */,
+      ".path-ver-erase-events.json" /* eraseEventsFilename */,
+      1000 /* syncEventGroupTimeout */,
+      syncOnEventGroupVerify /* syncOnEventGroup */,
+      true /* syncEventsCache */,
+      ".path-ver-sync-events.json" /* syncEventsFilename */,
+    )
+  })
+
+  await t.test(
+    "benchmarks a path draw and erase update sequentially",
+    async (/*t*/) => {
+      return runBidirectionalBenchmark(
+        "path draw and erase [sequential]" /* BENCHMARK */,
+        "plots/path-seq-benchmark.tsv" /* FILENAME */,
+        ITERATIONSLIST /* ITERATIONSLIST */,
+        BLOCKSIZE /* BLOCKSIZE */,
+        pathDraw /* addData */,
+        pathErase /* eraseData */,
+        addOnInitFrontendSequential /* addOnInitFrontend */,
+        100 /* addBroadcastGroupTimeout */,
+        addOnBroadcastGroupSequential /* addOnBroadcastGroup */,
+        ".path-seq-add-packets.json" /* addPacketsFilename */,
+        eraseOnInitFrontendSequential /* eraseOnInitFrontend */,
+        100 /* eraseBroadcastGroupTimeout */,
+        eraseOnBroadcastGroupSequential /* eraseOnBroadcastGroup */,
+        ".path-seq-erase-packets.json" /* erasePacketsFilename */,
+        1000 /* syncSendGroupTimeout */,
+        syncOnSendGroup /* syncOnSendGroup */,
+        ".path-seq-sync-packets.json" /* syncPacketsFilename */,
+        addOnInitBackendSequential /* addOnInitBackend */,
+        100 /* addEventGroupTimeout */,
+        addOnEventGroupSequential /* addOnEventGroup */,
+        false /* addEventsCache */,
+        ".path-seq-add-events.json" /* addEventsFilename */,
+        eraseOnInitBackendSequential /* eraseOnInitBackend */,
+        100 /* eraseEventGroupTimeout */,
+        eraseOnEventGroupSequential /* eraseOnEventGroupTimeout */,
+        false /* eraseEventsCache */,
+        ".path-seq-erase-events.json" /* eraseEventsFilename */,
+        1000 /* syncEventGroupTimeout */,
+        syncOnEventGroup /* syncOnEventGroup */,
+        false /* syncEventsCache */,
+        ".path-seq-sync-events.json" /* syncEventsFilename */,
+      )
+    },
+  )
+
+  await t.test(
+    "benchmarks a path draw and erase update in parallel",
+    async (/*t*/) => {
+      return runBidirectionalBenchmark(
+        "path draw and erase [parallel]" /* BENCHMARK */,
+        "plots/path-par-benchmark.tsv" /* FILENAME */,
+        ITERATIONSLIST /* ITERATIONSLIST */,
+        BLOCKSIZE /* BLOCKSIZE */,
+        pathDraw /* addData */,
+        pathErase /* eraseData */,
+        addOnInitFrontendParallel /* addOnInitFrontend */,
+        5000 /* addBroadcastGroupTimeout */,
+        addOnBroadcastGroupParallel /* addOnBroadcastGroup */,
+        ".path-par-add-packets.json" /* addPacketsFilename */,
+        eraseOnInitFrontendParallel /* eraseOnInitFrontend */,
+        5000 /* eraseBroadcastGroupTimeout */,
+        eraseOnBroadcastGroupParallel /* eraseOnBroadcastGroup */,
+        ".path-par-erase-packets.json" /* erasePacketsFilename */,
+        5000 /* syncSendGroupTimeout */,
+        syncOnSendGroup /* syncOnSendGroup */,
+        ".path-par-sync-packets.json" /* syncPacketsFilename */,
+        addOnInitBackendParallel /* addOnInitBackend */,
+        5000 /* addEventGroupTimeout */,
+        addOnEventGroupParallel /* addOnEventGroup */,
+        false /* addEventsCache */,
+        ".path-par-add-events.json" /* addEventsFilename */,
+        eraseOnInitBackendParallel /* eraseOnInitBackend */,
+        5000 /* eraseEventGroupTimeout */,
+        eraseOnEventGroupParallel /* eraseOnEventGroupTimeout */,
+        false /* eraseEventsCache */,
+        ".path-par-erase-events.json" /* eraseEventsFilename */,
+        5000 /* syncEventGroupTimeout */,
+        syncOnEventGroup /* syncOnEventGroup */,
+        false /* syncEventsCache */,
+        ".path-par-sync-events.json" /* syncEventsFilename */,
+      )
+    },
+  )
+})

__tests__/benchmark.data.js → __benchmarks__/data.js

-export function createMessageReceivedEvent(
-  message,
-  channel = "y-js",
-  uid = "moritz",
-) {
-  return {
-    detail: {
-      uid,
-      channel,
-      message,
-    },
-  }
-}
+export const handshake = Uint8Array.of(
+  133,
+  164,
+  117,
+  117,
+  105,
+  100,
+  217,
+  36,
+  97,
+  54,
+  100,
+  57,
+  50,
+  55,
+  97,
+  56,
+  45,
+  53,
+  50,
+  57,
+  101,
+  45,
+  52,
+  55,
+  50,
+  54,
+  45,
+  97,
+  102,
+  48,
+  98,
+  45,
+  56,
+  48,
+  57,
+  55,
+  98,
+  48,
+  48,
+  102,
+  55,
+  99,
+  49,
+  55,
+  167,
+  109,
+  101,
+  115,
+  115,
+  97,
+  103,
+  101,
+  196,
+  3,
+  162,
+  109,
+  108,
+  165,
+  115,
+  108,
+  105,
+  99,
+  101,
+  0,
+  166,
+  108,
+  101,
+  110,
+  103,
+  116,
+  104,
+  3,
+  170,
+  99,
+  111,
+  109,
+  112,
+  114,
+  101,
+  115,
+  115,
+  101,
+  100,
+  194,
+)
 
-export const handshake = {
-  uuid: "42c4566d-0cfe-4c00-a645-254b7887e477",
-  message: Uint8Array.of(162, 109, 108),
-  slice: 0,
-  length: 1,
-  compressed: false,
-}
-
-export const syncStep1 = {
-  uuid: "6e20b20d-e1d8-405d-8a61-d56cb1c47a24",
-  message: Uint8Array.of(
-    120,
-    156,
-    107,
-    93,
-    82,
-    82,
-    89,
-    144,
-    186,
-    186,
-    184,
-    50,
-    47,
-    89,
-    161,
-    184,
-    36,
-    181,
-    64,
-    193,
-    112,
-    69,
-    113,
-    73,
-    98,
-    73,
-    106,
-    112,
-    106,
-    73,
-    195,
-    202,
-    148,
-    212,
-    156,
-    84,
-    8,
-    115,
-    125,
-    65,
-    81,
-    126,
-    73,
-    126,
-    114,
-    126,
-    78,
-    88,
-    106,
-    81,
-    113,
-    102,
-    126,
-    30,
-    247,
-    146,
-    196,
-    210,
-    146,
-    140,
-    3,
-    0,
-    80,
-    113,
-    26,
-    230,
-  ),
-  slice: 0,
-  length: 1,
-  compressed: true,
-}
-
-export const syncDone = {
-  message: Uint8Array.of(
-    120,
-    156,
-    107,
-    92,
-    82,
-    82,
-    89,
-    144,
-    186,
-    178,
-    184,
-    50,
-    47,
-    89,
-    33,
-    37,
-    63,
-    47,
-    21,
-    0,
-    64,
-    79,
-    7,
-    20,
-  ),
-  slice: 0,
-  length: 1,
-  compressed: true,
-}
-
-export const dotDraw = [[209, 88, 5.000000000000001, "#0000ff"]]
+export const dotDraw = [[209, 88, 5.0, "#0000ff"]]
 export const dotErase = [[0, [[0, 0]]]]
 
 export const pathDraw = [
-  [229, 147, 5.000000000000001, "#0000ff"],
-  [239, 149, 5.000000000000001, "#0000ff"],
-  [265, 154, 5.000000000000001, "#0000ff"],
-  [329, 158, 5.000000000000001, "#0000ff"],
-  [428, 168, 5.000000000000001, "#0000ff"],
-  [559, 172, 5.000000000000001, "#0000ff"],
-  [689, 176, 5.000000000000001, "#0000ff"],
-  [789, 176, 5.000000000000001, "#0000ff"],
-  [871, 178, 5.000000000000001, "#0000ff"],
-  [915, 179, 5.000000000000001, "#0000ff"],
-  [937, 179, 5.000000000000001, "#0000ff"],
-  [942, 179, 5.000000000000001, "#0000ff"],
+  [229, 147, 5.0, "#0000ff"],
+  [239, 149, 5.0, "#0000ff"],
+  [265, 154, 5.0, "#0000ff"],
+  [329, 158, 5.0, "#0000ff"],
+  [428, 168, 5.0, "#0000ff"],
+  [559, 172, 5.0, "#0000ff"],
+  [689, 176, 5.0, "#0000ff"],
+  [789, 176, 5.0, "#0000ff"],
+  [871, 178, 5.0, "#0000ff"],
+  [915, 179, 5.0, "#0000ff"],
+  [937, 179, 5.0, "#0000ff"],
+  [942, 179, 5.0, "#0000ff"],
 ]
 export const pathErase = [
   [0, [[0, 0.030367582231477598]]],

__benchmarks__/puppeteer.js

+import puppeteer from "puppeteer-core"
+import fs from "fs"
+;(async () => {
+  const browser = await puppeteer.launch({
+    executablePath: "google-chrome",
+    headless: true,
+    args: [
+      "--js-flags=--expose-gc",
+      "--no-sandbox",
+      "--enable-precise-memory-info",
+    ],
+  })
+  const page = await browser.newPage()
+
+  const done = new Promise((resolve) => {
+    page.on("console", (msg) => {
+      if (msg.type() == "debug") {
+        process.stderr.write(msg.text())
+      } else if (msg.type() == "info") {
+        const { filename, title, iterations, results } = JSON.parse(msg.text())
+
+        if (title) {
+          const columns = ["iterations"]
+
+          for (const title of results) {
+            columns.push(`${title}_timeLoc`)
+            columns.push(`${title}_encodeRAM`)
+            columns.push(`${title}_packets`)
+            columns.push(`${title}_size`)
+            columns.push(`${title}_timeRem`)
+            columns.push(`${title}_decodeRAM`)
+            columns.push(`${title}_events`)
+          }
+
+          fs.writeFileSync(
+            filename,
+            `# Benchmark: ${title}\n# ${columns.join("\t")}\n`,
+          )
+        } else {
+          const columns = [iterations]
+
+          for (const title in results) {
+            const {
+              timeLoc,
+              encodeRAM,
+              packets,
+              size,
+              timeRem,
+              decodeRAM,
+              events,
+            } = results[title]
+
+            columns.push(timeLoc)
+            columns.push(encodeRAM)
+            columns.push(packets)
+            columns.push(size)
+            columns.push(timeRem)
+            columns.push(decodeRAM)
+            columns.push(events)
+          }
+
+          fs.appendFileSync(filename, `${columns.join("\t")}\n`)
+        }
+      } else if (msg.type() == "log") {
+        if (msg.text().startsWith("# failure")) {
+          resolve()
+        }
+
+        process.stdout.write(msg.text() + "\n")
+      }
+    })
+  })
+
+  await page.goto("http://localhost:3000/benchmarks.html").catch(console.error)
+
+  await done
+
+  await browser.close()
+})()

__e2e_tests__/peer1.e2e.js

@@ -29,5 +29,6 @@ test("Clicking and dragging on canvas creates a single child element", async (t)
     .drag(canvas, 10, 10)
     .wait(syncTimeout)
     .expect(canvas.childElementCount)
-    .eql(1)
+    // first draw also creates last recognised path placeholder
+    .eql(2)
 })

__e2e_tests__/peer2.e2e.js

@@ -6,6 +6,7 @@ const port = 3000
 fixture`Peer 2`.page`${host}:${port}`
 
 const idAppearTimeout = 1000
+const syncTimeout = 15000
 const selectorOptions = { timeout: 1000 }
 
 test("Connection id appears", async (t) => {
@@ -23,5 +24,5 @@ test("Connection id appears", async (t) => {
 
 test("Canvas eventually gets a child element", async (t) => {
   const canvas = Selector("#canvas").with(selectorOptions)
-  await t.expect(canvas.childElementCount).eql(1, { timeout: 10000 })
+  await t.expect(canvas.childElementCount).eql(1, { timeout: syncTimeout })
 })

__tests__/benchmark.test.js

-import fs from "fs"
-import chalk from "chalk"
-
-import { connect } from "../src/room.js"
-
-import MockConnection, {
-  getUserID,
-  getPeerHandle,
-  getPeerFootprint,
-  send,
-  sendListener,
-  broadcast,
-  broadcastListener,
-  terminatePeer,
-  destructor,
-  addEventListener,
-  getEventListener,
-} from "../src/connection/MockConnection.js"
-
-import {
-  createMessageReceivedEvent,
-  handshake,
-  syncStep1,
-  syncDone,
-  dotDraw,
-  dotErase,
-  pathDraw,
-  pathErase,
-} from "./benchmark.data.js"
-
-// Adapted from https://github.com/jprichardson/buffer-json (MIT license)
-
-function stringify(value, space) {
-  return JSON.stringify(value, replacer, space)
-}
-
-function parse(text) {
-  return JSON.parse(text, reviver)
-}
-
-function replacer(key, value) {
-  if (value instanceof Uint8Array) {
-    return "base64:" + Buffer.from(value).toString("base64")
-  }
-  return value
-}
-
-function reviver(key, value) {
-  if (typeof value == "string" && value.startsWith("base64:")) {
-    return Uint8Array.from(Buffer.from(value.slice("base64:".length), "base64"))
-  }
-  return value
-}
-
-function dumpBSON(filename, data) {
-  return fs.writeFileSync(filename, stringify(data))
-}
-
-function loadBSON(filename) {
-  return parse(fs.readFileSync(filename))
-}
-
-function printBenchmark(title, iterations, results) {
-  process.stdout.write(`\n  ${title} (${iterations} iterations):\n`)
-
-  for (const title in results) {
-    const { timeLoc, packets, size, timeRem, events } = results[title]
-    const synchronisation = title == "synchronisation"
-
-    process.stdout.write(
-      chalk`    {yellow ⧗} {dim ${title}:} {yellow.inverse ${(
-        timeLoc /
-        (1e6 * (synchronisation ? 1 : iterations))
-      ).toFixed(3)}ms ${
-        synchronisation ? "total" : "/ it"
-      }} => {dim ${packets} packet(s)} => {magenta.inverse ${size}B} => {yellow.inverse ${(
-        timeRem /
-        (1e6 * (synchronisation ? 1 : iterations))
-      ).toFixed(3)}ms ${
-        synchronisation ? "total" : "/ it"
-      }} => {dim ${events} event(s)}\n`,
-    )
-  }
-
-  process.stdout.write(`\n`)
-}
-
-//let room = null
-//let updateRoom = null
-//let syncRoom = null
-
-describe("drawing app mesh", () => {
-  beforeEach(() => {
-    getUserID.mockClear()
-    getPeerHandle.mockClear()
-    getPeerFootprint.mockClear()
-    send.mockClear()
-    broadcast.mockClear()
-    terminatePeer.mockClear()
-    destructor.mockClear()
-    addEventListener.mockClear()
-    MockConnection.mockClear()
-
-    /*room = await connect("room", MockConnection)
-    getEventListener(
-      "room",
-      "messageReceived",
-    )(createMessageReceivedEvent(handshake, "tw-ml"))
-
-    updateRoom = await connect("update", MockConnection)
-    getEventListener(
-      "update",
-      "messageReceived",
-    )(createMessageReceivedEvent(handshake, "tw-ml"))
-
-    syncRoom = await connect("sync", MockConnection)
-    getEventListener(
-      "sync",
-      "messageReceived",
-    )(createMessageReceivedEvent(handshake, "tw-ml"))*/
-  })
-
-  /*afterEach(() => {
-    room.disconnect()
-    room = null
-
-    updateRoom.disconnect()
-    updateRoom = null
-
-    syncRoom.disconnect()
-    syncRoom = null
-  })*/
-
-  it("benchmarks a single draw and erase update sequentially", () => {
-    const ITERATIONS = 1000
-
-    jest.setTimeout(ITERATIONS * 400)
-
-    const dotIDs = []
-    let prevTime
-
-    let broadcasts = 0
-
-    let addLocTime = 0
-    let addPackets = []
-    let addSize = 0
-    let eraseLocTime = 0
-    let erasePackets = []
-    let eraseSize = 0
-    let syncLocTime
-    let syncPackets = []
-    let syncSize = 0
-
-    let addRemTime = 0
-    let addEvents = 0
-    let eraseRemTime = 0
-    let eraseEvents = 0
-    let syncRemTime = 0
-    let syncEvents = 0
-
-    let timeout
-
-    let room
-    let updateRoom
-    let syncRoom
-
-    return new Promise(async (resolve) => {
-      room = await connect("room", MockConnection)
-      getEventListener(
-        "room",
-        "messageReceived",
-      )(createMessageReceivedEvent(handshake, "tw-ml"))
-      return resolve()
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            broadcastListener.callback = (channel, message) => {
-              const currTime = process.hrtime()
-
-              broadcasts += 1
-
-              if (broadcasts <= ITERATIONS) {
-                addLocTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-                addPackets.push(message)
-                addSize += message.message.length
-              } else {
-                eraseLocTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-                erasePackets.push(message)
-                eraseSize += message.message.length
-              }
-
-              prevTime = process.hrtime()
-
-              if (broadcasts < ITERATIONS) {
-                dotIDs.push(room.addPath(dotDraw[0]))
-              } else if (broadcasts < ITERATIONS * 2) {
-                room.extendErasureIntervals(
-                  dotIDs[broadcasts - ITERATIONS],
-                  dotErase[0][0],
-                  dotErase[0][1],
-                )
-              } else {
-                resolve()
-              }
-            }
-
-            prevTime = process.hrtime()
-
-            dotIDs.push(room.addPath(dotDraw[0]))
-          }),
-      )
-      .then(() => {
-        broadcastListener.callback = null
-
-        dumpBSON("dot-seq-add.json", addPackets)
-        addPackets = null
-
-        dumpBSON("dot-seq-erase.json", erasePackets)
-        erasePackets = null
-      })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            sendListener.callback = (uid, channel, message) => {
-              const currTime = process.hrtime()
-              syncLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-
-              syncPackets.push(message)
-              syncSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            prevTime = process.hrtime()
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(() => {
-        sendListener.callback = null
-
-        dumpBSON("dot-seq-sync.json", syncPackets)
-        syncPackets = null
-
-        room.disconnect()
-        room = null
-      })
-      .then(
-        () =>
-          new Promise(async (resolve) => {
-            updateRoom = await connect("update", MockConnection)
-            getEventListener(
-              "update",
-              "messageReceived",
-            )(createMessageReceivedEvent(handshake, "tw-ml"))
-
-            addPackets = loadBSON("dot-seq-add.json")
-            erasePackets = loadBSON("dot-seq-erase.json")
-
-            return resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            broadcasts = 0
-
-            let currTime
-
-            const timeoutCallback = () => {
-              broadcasts += 1
-
-              // TODO: can we assume that we only use one message here?
-              if (broadcasts <= ITERATIONS) {
-                addRemTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-              } else {
-                eraseRemTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-              }
-
-              let packet
-
-              if (broadcasts < ITERATIONS) {
-                packet = addPackets[broadcasts]
-              } else if (broadcasts < ITERATIONS * 2) {
-                packet = erasePackets[broadcasts - ITERATIONS]
-              } else {
-                return resolve()
-              }
-
-              prevTime = process.hrtime()
-
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(packet))
-            }
-
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              currTime = process.hrtime()
-
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(timeoutCallback, 100)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              currTime = process.hrtime()
-
-              if (broadcasts < ITERATIONS) {
-                addEvents += 1
-              } else if (broadcasts < ITERATIONS * 2) {
-                eraseEvents += 1
-              }
-
-              clearTimeout(timeout)
-              timeout = setTimeout(timeoutCallback, 100)
-            })
-
-            prevTime = process.hrtime()
-
-            getEventListener(
-              "update",
-              "messageReceived",
-            )(createMessageReceivedEvent(addPackets[0]))
-          }),
-      )
-      .then(() => {
-        addPackets = null
-        erasePackets = null
-
-        updateRoom.disconnect()
-        updateRoom = null
-      })
-      .then(
-        () =>
-          new Promise(async (resolve) => {
-            syncRoom = await connect("sync", MockConnection)
-            getEventListener(
-              "sync",
-              "messageReceived",
-            )(createMessageReceivedEvent(handshake, "tw-ml"))
-
-            syncPackets = loadBSON("dot-seq-sync.json")
-
-            return resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            syncRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            syncRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            prevTime = process.hrtime()
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(() => {
-        syncPackets = null
-
-        syncRoom.disconnect()
-        syncRoom = null
-      })
-      .then(() => {
-        addPackets = loadBSON("dot-seq-add.json").length
-        erasePackets = loadBSON("dot-seq-erase.json").length
-        syncPackets = loadBSON("dot-seq-sync.json").length
-
-        printBenchmark("single draw and erase [sequential]", ITERATIONS, {
-          addPath: {
-            timeLoc: addLocTime,
-            packets: addPackets,
-            size: addSize,
-            timeRem: addRemTime,
-            events: addEvents,
-          },
-          extendErasureIntervals: {
-            timeLoc: eraseLocTime,
-            packets: erasePackets,
-            size: eraseSize,
-            timeRem: eraseRemTime,
-            events: eraseEvents,
-          },
-          synchronisation: {
-            timeLoc: syncLocTime,
-            packets: syncPackets,
-            size: syncSize,
-            timeRem: syncRemTime,
-            events: syncEvents,
-          },
-        })
-      })
-  })
-
-  /*it("benchmarks a single draw and erase update in parallel", () => {
-    const ITERATIONS = 1000
-
-    jest.setTimeout(ITERATIONS * 20)
-
-    const dotIDs = []
-    let prevTime
-
-    let addLocTime
-    const addPackets = []
-    let addSize = 0
-    let eraseLocTime
-    const erasePackets = []
-    let eraseSize = 0
-    let syncLocTime
-    const syncPackets = []
-    let syncSize = 0
-
-    let addRemTime = 0
-    let addEvents = 0
-    let eraseRemTime = 0
-    let eraseEvents = 0
-    let syncRemTime = 0
-    let syncEvents = 0
-
-    let timeout
-
-    return new Promise((resolve) => {
-      broadcastListener.callback = (channel, message) => {
-        const currTime = process.hrtime()
-
-        addLocTime =
-          (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-        addPackets.push(message)
-        addSize += message.message.length
-
-        clearTimeout(timeout)
-        timeout = setTimeout(() => resolve(), 1000)
-      }
-
-      prevTime = process.hrtime()
-
-      for (let i = 0; i < ITERATIONS; i++) {
-        dotIDs.push(room.addPath(dotDraw[0]))
-      }
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            broadcastListener.callback = (channel, message) => {
-              const currTime = process.hrtime()
-
-              eraseLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              erasePackets.push(message)
-              eraseSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => {
-                resolve()
-              }, 1000)
-            }
-
-            prevTime = process.hrtime()
-
-            for (let i = 0; i < ITERATIONS; i++) {
-              room.extendErasureIntervals(
-                dotIDs[i],
-                dotErase[0][0],
-                dotErase[0][1],
-              )
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            sendListener.callback = (uid, channel, message) => {
-              const currTime = process.hrtime()
-              syncLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-
-              syncPackets.push(message)
-              syncSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            prevTime = process.hrtime()
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              addRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              addRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            for (const addPacket of addPackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(addPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              eraseRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              eraseEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              eraseRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              eraseEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            for (const erasePacket of erasePackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(erasePacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            syncRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            syncRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            printBenchmark("single draw and erase [parallel]", ITERATIONS, {
-              addPath: {
-                timeLoc: addLocTime,
-                packets: addPackets.length,
-                size: addSize,
-                timeRem: addRemTime,
-                events: addEvents,
-              },
-              extendErasureIntervals: {
-                timeLoc: eraseLocTime,
-                packets: erasePackets.length,
-                size: eraseSize,
-                timeRem: eraseRemTime,
-                events: eraseEvents,
-              },
-              synchronisation: {
-                timeLoc: syncLocTime,
-                packets: syncPackets.length,
-                size: syncSize,
-                timeRem: syncRemTime,
-                events: syncEvents,
-              },
-            })
-
-            resolve()
-          }),
-      )
-  })
-
-  it("communicates a single draw and erase update", () => {
-    jest.setTimeout(30000)
-
-    let dotID
-
-    const addPackets = []
-    const erasePackets = []
-    const syncPackets = []
-    let syncDonePacket = -1
-
-    const updatePaths = {}
-    const updateIntervals = {}
-    const syncPaths = {}
-    const syncIntervals = {}
-
-    let timeout
-
-    return new Promise((resolve) => {
-      // Draw the dot
-      broadcastListener.callback = (channel, message) => {
-        expect(channel).toEqual("y-js")
-        expect(message.message instanceof Uint8Array).toBe(true)
-
-        addPackets.push(message)
-
-        clearTimeout(timeout)
-        timeout = setTimeout(() => resolve(), 1000)
-      }
-
-      dotID = room.addPath(dotDraw[0])
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Erase the dot
-            broadcastListener.callback = (channel, message) => {
-              expect(channel).toEqual("y-js")
-              expect(message.message instanceof Uint8Array).toBe(true)
-
-              erasePackets.push(message)
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            room.extendErasureIntervals(dotID, dotErase[0][0], dotErase[0][1])
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Request a sync step 2
-            sendListener.callback = (uid, channel, message) => {
-              expect(uid).toEqual("moritz")
-              expect(channel).toEqual("y-js")
-              expect(message.message instanceof Uint8Array).toBe(true)
-
-              syncPackets.push(message)
-
-              if (
-                message.message.length == syncDone.message.length &&
-                JSON.stringify(
-                  Object.assign({}, message, { uuid: undefined }),
-                ) == JSON.stringify(syncDone)
-              ) {
-                expect(syncDonePacket).toEqual(-1)
-
-                syncDonePacket = syncPackets.length
-              }
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => {
-                expect(syncDonePacket).toEqual(syncPackets.length)
-
-                resolve()
-              }, 1000)
-            }
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the draw updates
-            updateRoom.addEventListener(
-              "addOrUpdatePath",
-              ({ detail: { id, points } }) => {
-                updatePaths[id] = points
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            updateRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                updateIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const addPacket of addPackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(addPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the draw updates
-            expect(updatePaths).toStrictEqual({ [dotID]: dotDraw })
-            expect(updateIntervals).toStrictEqual({ [dotID]: {} })
-
-            resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the erase updates
-            updateRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                updateIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const erasePacket of erasePackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(erasePacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the erase updates
-            expect(updatePaths).toStrictEqual({ [dotID]: dotDraw })
-            expect(updateIntervals).toStrictEqual({
-              [dotID]: { [dotErase[0][0]]: dotErase[0][1] },
-            })
-
-            resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the synchronisation
-            syncRoom.addEventListener(
-              "addOrUpdatePath",
-              ({ detail: { id, points } }) => {
-                syncPaths[id] = points
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            syncRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                syncIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the synchronisation
-            expect(syncPaths).toStrictEqual({ [dotID]: dotDraw })
-            expect(syncIntervals).toStrictEqual({
-              [dotID]: { [dotErase[0][0]]: dotErase[0][1] },
-            })
-
-            resolve()
-          }),
-      )
-  })
-
-  it("benchmarks a path draw and erase update sequentially", () => {
-    const ITERATIONS = 1000
-
-    jest.setTimeout(ITERATIONS * 1500)
-
-    const pathIDs = []
-    let prevTime
-    let currTime
-
-    let broadcasts = 0
-
-    let addLocTime = 0
-    const addPackets = []
-    let addSize = 0
-    let eraseLocTime = 0
-    const erasePackets = []
-    let eraseSize = 0
-    let syncLocTime
-    const syncPackets = []
-    let syncSize = 0
-
-    let addRemTime = 0
-    let addEvents = 0
-    let eraseRemTime = 0
-    let eraseEvents = 0
-    let syncRemTime = 0
-    let syncEvents = 0
-
-    let timeout
-
-    return new Promise((resolve) => {
-      broadcastListener.callback = (channel, message) => {
-        currTime = process.hrtime()
-
-        if (broadcasts < ITERATIONS) {
-          addPackets[addPackets.length - 1].push(message)
-          addSize += message.message.length
-        } else {
-          erasePackets[erasePackets.length - 1].push(message)
-          eraseSize += message.message.length
-        }
-
-        clearTimeout(timeout)
-        timeout = setTimeout(() => {
-          broadcasts += 1
-
-          if (broadcasts <= ITERATIONS) {
-            addLocTime +=
-              (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-          } else {
-            eraseLocTime +=
-              (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-          }
-
-          prevTime = process.hrtime()
-
-          if (broadcasts < ITERATIONS) {
-            addPackets.push([])
-
-            const tmpPathID = room.addPath(pathDraw[0])
-            pathIDs.push(tmpPathID)
-            for (let i = 1; i < pathDraw.length; i++) {
-              room.extendPath(tmpPathID, pathDraw[i])
-            }
-          } else if (broadcasts < ITERATIONS * 2) {
-            erasePackets.push([])
-
-            const tmpPathID = pathIDs[broadcasts - ITERATIONS]
-
-            for (let i = 0; i < pathErase.length; i++) {
-              room.extendErasureIntervals(
-                tmpPathID,
-                pathErase[i][0],
-                pathErase[i][1],
-              )
-            }
-          } else {
-            resolve()
-          }
-        }, 100)
-      }
-
-      addPackets.push([])
-
-      prevTime = process.hrtime()
-
-      const tmpPathID = room.addPath(pathDraw[0])
-      pathIDs.push(tmpPathID)
-      for (let i = 1; i < pathDraw.length; i++) {
-        room.extendPath(tmpPathID, pathDraw[i])
-      }
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            sendListener.callback = (uid, channel, message) => {
-              const currTime = process.hrtime()
-              syncLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-
-              syncPackets.push(message)
-              syncSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            prevTime = process.hrtime()
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            broadcasts = 0
-
-            let currTime
-
-            const timeoutCallback = () => {
-              broadcasts += 1
-
-              if (broadcasts <= ITERATIONS) {
-                addRemTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-              } else {
-                eraseRemTime +=
-                  (currTime[0] - prevTime[0]) * 1e9 +
-                  (currTime[1] - prevTime[1])
-              }
-
-              let packets
-
-              if (broadcasts < ITERATIONS) {
-                packets = addPackets[broadcasts]
-              } else if (broadcasts < ITERATIONS * 2) {
-                packets = erasePackets[broadcasts - ITERATIONS]
-              } else {
-                return resolve()
-              }
-
-              prevTime = process.hrtime()
-
-              for (const packet of packets) {
-                getEventListener(
-                  "update",
-                  "messageReceived",
-                )(createMessageReceivedEvent(packet))
-              }
-            }
-
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              currTime = process.hrtime()
-
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(timeoutCallback, 100)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              currTime = process.hrtime()
-
-              if (broadcasts < ITERATIONS) {
-                addEvents += 1
-              } else if (broadcasts < ITERATIONS * 2) {
-                eraseEvents += 1
-              }
-
-              clearTimeout(timeout)
-              timeout = setTimeout(timeoutCallback, 100)
-            })
-
-            prevTime = process.hrtime()
-
-            for (const packet of addPackets[0]) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(packet))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            syncRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            syncRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            prevTime = process.hrtime()
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(() => {
-        printBenchmark("path draw and erase [sequential]", ITERATIONS, {
-          addPath: {
-            timeLoc: addLocTime,
-            packets: addPackets.reduce(
-              (sum, packets) => sum + packets.length,
-              0,
-            ),
-            size: addSize,
-            timeRem: addRemTime,
-            events: addEvents,
-          },
-          extendErasureIntervals: {
-            timeLoc: eraseLocTime,
-            packets: erasePackets.reduce(
-              (sum, packets) => sum + packets.length,
-              0,
-            ),
-            size: eraseSize,
-            timeRem: eraseRemTime,
-            events: eraseEvents,
-          },
-          synchronisation: {
-            timeLoc: syncLocTime,
-            packets: syncPackets.length,
-            size: syncSize,
-            timeRem: syncRemTime,
-            events: syncEvents,
-          },
-        })
-      })
-  })
-
-  it("benchmarks a path draw and erase update in parallel", () => {
-    const ITERATIONS = 1000
-    const BLOCKSIZE = 10
-
-    jest.setTimeout(ITERATIONS * 1800)
-
-    const pathIDs = []
-    let prevTime
-
-    let addLocTime
-    const addPackets = []
-    let addSize = 0
-    let eraseLocTime
-    const erasePackets = []
-    let eraseSize = 0
-    let syncLocTime
-    const syncPackets = []
-    let syncSize = 0
-
-    let addRemTime = 0
-    let addEvents = 0
-    let eraseRemTime = 0
-    let eraseEvents = 0
-    let syncRemTime = 0
-    let syncEvents = 0
-
-    let timeout
-
-    return new Promise((resolve) => {
-      broadcastListener.callback = (channel, message) => {
-        const currTime = process.hrtime()
-
-        addLocTime =
-          (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-        addPackets.push(message)
-        addSize += message.message.length
-
-        clearTimeout(timeout)
-        timeout = setTimeout(() => resolve(), 1000)
-      }
-
-      prevTime = process.hrtime()
-
-      for (let j = 0; j < ITERATIONS; j++) {
-        const tmpPathID = room.addPath(pathDraw[0])
-        pathIDs.push(tmpPathID)
-        for (let i = 1; i < pathDraw.length; i++) {
-          room.extendPath(tmpPathID, pathDraw[i])
-        }
-      }
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            broadcastListener.callback = (channel, message) => {
-              const currTime = process.hrtime()
-
-              eraseLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              erasePackets.push(message)
-              eraseSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => {
-                resolve()
-              }, 10000)
-            }
-
-            // Necessary to allow yjs to execute transactions (majority of processing time)
-            function erasePath(sj) {
-              if (sj >= ITERATIONS) return
-
-              for (let j = sj; j < Math.min(sj + BLOCKSIZE, ITERATIONS); j++) {
-                const tmpPathID = pathIDs[j]
-
-                for (let i = 0; i < pathErase.length; i++) {
-                  room.extendErasureIntervals(
-                    tmpPathID,
-                    pathErase[i][0],
-                    pathErase[i][1],
-                  )
-                }
-              }
-
-              setTimeout(erasePath, 0, sj + BLOCKSIZE)
-            }
-
-            prevTime = process.hrtime()
-            erasePath(0)
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            sendListener.callback = (uid, channel, message) => {
-              const currTime = process.hrtime()
-              syncLocTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-
-              syncPackets.push(message)
-              syncSize += message.message.length
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            prevTime = process.hrtime()
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              addRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              addRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              addEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            for (const addPacket of addPackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(addPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            updateRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              eraseRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              eraseEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            updateRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              eraseRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              eraseEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            // Necessary to allow yjs to execute transactions (majority of processing time)
-            function erasePath(sj) {
-              if (sj >= erasePackets.length) return
-
-              for (
-                let j = sj;
-                j < Math.min(sj + BLOCKSIZE * 10, erasePackets.length);
-                j++
-              ) {
-                getEventListener(
-                  "update",
-                  "messageReceived",
-                )(createMessageReceivedEvent(erasePackets[j]))
-              }
-
-              setTimeout(erasePath, 0, sj + BLOCKSIZE * 10)
-            }
-
-            prevTime = process.hrtime()
-            erasePath(0)
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            syncRoom.addEventListener("addOrUpdatePath", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            syncRoom.addEventListener("removedIntervalsChange", () => {
-              const currTime = process.hrtime()
-
-              syncRemTime =
-                (currTime[0] - prevTime[0]) * 1e9 + (currTime[1] - prevTime[1])
-              syncEvents += 1
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            })
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(() => {
-        printBenchmark("path draw and erase [parallel]", ITERATIONS, {
-          addPath: {
-            timeLoc: addLocTime,
-            packets: addPackets.length,
-            size: addSize,
-            timeRem: addRemTime,
-            events: addEvents,
-          },
-          extendErasureIntervals: {
-            timeLoc: eraseLocTime,
-            packets: erasePackets.length,
-            size: eraseSize,
-            timeRem: eraseRemTime,
-            events: eraseEvents,
-          },
-          synchronisation: {
-            timeLoc: syncLocTime,
-            packets: syncPackets.length,
-            size: syncSize,
-            timeRem: syncRemTime,
-            events: syncEvents,
-          },
-        })
-      })
-  })
-
-  it("communicates a path draw and erase update", () => {
-    jest.setTimeout(15000)
-
-    let pathID
-
-    const addPackets = []
-    const erasePackets = []
-    const syncPackets = []
-    let syncDonePacket = -1
-
-    const updatePaths = {}
-    const updateIntervals = {}
-    const syncPaths = {}
-    const syncIntervals = {}
-
-    let timeout
-
-    return new Promise((resolve) => {
-      // Draw the path
-      broadcastListener.callback = (channel, message) => {
-        expect(channel).toEqual("y-js")
-        expect(message.message instanceof Uint8Array).toBe(true)
-
-        addPackets.push(message)
-
-        clearTimeout(timeout)
-        timeout = setTimeout(() => resolve(), 1000)
-      }
-
-      pathID = room.addPath(pathDraw[0])
-      for (let i = 1; i < pathDraw.length; i++) {
-        room.getPathPoints(pathID)
-        room.extendPath(pathID, pathDraw[i])
-      }
-    })
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Erase the path
-            broadcastListener.callback = (channel, message) => {
-              expect(channel).toEqual("y-js")
-              expect(message.message instanceof Uint8Array).toBe(true)
-
-              erasePackets.push(message)
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => resolve(), 1000)
-            }
-
-            for (let i = 0; i < pathErase.length; i++) {
-              room.extendErasureIntervals(
-                pathID,
-                pathErase[i][0],
-                pathErase[i][1],
-              )
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Request a sync step 2
-            sendListener.callback = (uid, channel, message) => {
-              expect(uid).toEqual("moritz")
-              expect(channel).toEqual("y-js")
-              expect(message.message instanceof Uint8Array).toBe(true)
-
-              syncPackets.push(message)
-
-              if (
-                message.message.length == syncDone.message.length &&
-                JSON.stringify(Object.assign(message, { uuid: undefined })) ==
-                  JSON.stringify(syncDone)
-              ) {
-                expect(syncDonePacket).toEqual(-1)
-
-                syncDonePacket = syncPackets.length
-              }
-
-              clearTimeout(timeout)
-              timeout = setTimeout(() => {
-                expect(syncDonePacket).toEqual(syncPackets.length)
-
-                resolve()
-              }, 1000)
-            }
-
-            getEventListener(
-              "room",
-              "messageReceived",
-            )(createMessageReceivedEvent(syncStep1))
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the draw updates
-            updateRoom.addEventListener(
-              "addOrUpdatePath",
-              ({ detail: { id, points } }) => {
-                updatePaths[id] = points
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            updateRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                updateIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const addPacket of addPackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(addPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the draw updates
-            expect(updatePaths).toStrictEqual({ [pathID]: pathDraw })
-            expect(updateIntervals).toStrictEqual({ [pathID]: {} })
-
-            resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the erase updates
-            updateRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                updateIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const erasePacket of erasePackets) {
-              getEventListener(
-                "update",
-                "messageReceived",
-              )(createMessageReceivedEvent(erasePacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the erase updates
-            expect(updatePaths).toStrictEqual({ [pathID]: pathDraw })
-            expect(updateIntervals).toStrictEqual({
-              [pathID]: Object.assign(
-                {},
-                new Array(pathDraw.length).fill([[0, 1]]),
-              ),
-            })
-
-            resolve()
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Replay the synchronisation
-            syncRoom.addEventListener(
-              "addOrUpdatePath",
-              ({ detail: { id, points } }) => {
-                syncPaths[id] = points
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            syncRoom.addEventListener(
-              "removedIntervalsChange",
-              ({ detail: { id, intervals } }) => {
-                syncIntervals[id] = intervals
-
-                clearTimeout(timeout)
-                timeout = setTimeout(() => resolve(), 1000)
-              },
-            )
-
-            for (const syncPacket of syncPackets) {
-              getEventListener(
-                "sync",
-                "messageReceived",
-              )(createMessageReceivedEvent(syncPacket))
-            }
-          }),
-      )
-      .then(
-        () =>
-          new Promise((resolve) => {
-            // Check the synchronisation
-            expect(syncPaths).toStrictEqual({ [pathID]: pathDraw })
-            expect(syncIntervals).toStrictEqual({
-              [pathID]: Object.assign(
-                {},
-                new Array(pathDraw.length).fill([[0, 1]]),
-              ),
-            })
-
-            resolve()
-          }),
-      )
-  })*/
-})

__tests__/shape.test.js

+import recognizeFromPoints, { Shapes } from "../src/shapes"
+
+describe("shape recognition", () => {
+  describe("general", () => {
+    test("should return a shape description object", () => {
+      const points = [[0, 0]]
+      const result = recognizeFromPoints(points)
+      expect(result).not.toBeNull()
+    })
+  })
+
+  describe("lines", () => {
+    test("should recognize a simple horizontal line", () => {
+      const points = [
+        [0, 0],
+        [100, 0],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+      expect(result.firstPoint).toStrictEqual([0, 0])
+      expect(result.lastPoint).toStrictEqual([100, 0])
+    })
+
+    test("should recognize a simple vertical line", () => {
+      const points = [
+        [0, 50],
+        [0, -100],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+      expect(result.firstPoint).toStrictEqual([0, 50])
+      expect(result.lastPoint).toStrictEqual([0, -100])
+    })
+
+    test("should recognize a slightly curve horizontal line", () => {
+      const points = [
+        [0, 0],
+        [30, 5],
+        [100, 0],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should not recognize a heavily curved horizontal line", () => {
+      const points = [
+        [0, 0],
+        [30, 30],
+        [100, -4],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).not.toBe(Shapes.line)
+    })
+
+    test("should recognize a long horizontal line", () => {
+      const points = [
+        [48.675496688741724, 197.8062913907285],
+        [50.66225165562914, 197.8062913907285],
+        [53.64238410596026, 197.8062913907285],
+        [57.6158940397351, 197.8062913907285],
+        [61.58940397350993, 197.8062913907285],
+        [66.55629139072848, 197.8062913907285],
+        [71.52317880794702, 197.8062913907285],
+        [76.49006622516558, 197.8062913907285],
+        [77.48344370860927, 197.8062913907285],
+        [82.45033112582782, 197.8062913907285],
+        [84.43708609271523, 197.8062913907285],
+        [87.41721854304636, 197.8062913907285],
+        [88.41059602649007, 197.8062913907285],
+        [88.41059602649007, 197.8062913907285],
+        [89.40397350993378, 197.8062913907285],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should recognize a long vertical line", () => {
+      const points = [
+        [218.54304635761588, 84.56125827814569],
+        [218.54304635761588, 86.54801324503312],
+        [218.54304635761588, 87.54139072847681],
+        [218.54304635761588, 88.53476821192052],
+        [218.54304635761588, 90.52152317880794],
+        [218.54304635761588, 91.51490066225165],
+        [218.54304635761588, 92.50827814569537],
+        [218.54304635761588, 93.50165562913908],
+        [218.54304635761588, 94.49503311258277],
+        [218.54304635761588, 94.49503311258277],
+        [218.54304635761588, 95.4884105960265],
+        [218.54304635761588, 96.4817880794702],
+        [218.54304635761588, 97.4751655629139],
+        [218.54304635761588, 98.46854304635761],
+        [218.54304635761588, 100.45529801324503],
+        [218.54304635761588, 101.44867549668874],
+        [218.54304635761588, 103.43543046357617],
+        [218.54304635761588, 105.42218543046357],
+        [218.54304635761588, 108.4023178807947],
+        [218.54304635761588, 110.38907284768212],
+        [218.54304635761588, 112.37582781456953],
+        [218.54304635761588, 114.36258278145695],
+        [218.54304635761588, 116.34933774834438],
+        [218.54304635761588, 118.33609271523179],
+        [218.54304635761588, 119.32947019867551],
+        [218.54304635761588, 120.3228476821192],
+        [218.54304635761588, 122.30960264900662],
+        [218.54304635761588, 123.30298013245033],
+        [218.54304635761588, 124.29635761589404],
+        [218.54304635761588, 125.28973509933775],
+        [218.54304635761588, 125.28973509933775],
+        [218.54304635761588, 125.28973509933775],
+        [218.54304635761588, 126.28311258278147],
+        [218.54304635761588, 126.28311258278147],
+        [218.54304635761588, 127.27649006622516],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should recognize a line at 20 degrees", () => {
+      const points = [
+        [34.7682119205298, 268.3360927152318],
+        [34.7682119205298, 268.3360927152318],
+        [36.75496688741722, 268.3360927152318],
+        [37.74834437086093, 268.3360927152318],
+        [38.741721854304636, 268.3360927152318],
+        [39.735099337748345, 268.3360927152318],
+        [40.728476821192054, 268.3360927152318],
+        [41.721854304635755, 268.3360927152318],
+        [42.71523178807947, 268.3360927152318],
+        [43.70860927152318, 268.3360927152318],
+        [43.70860927152318, 268.3360927152318],
+        [44.70198675496689, 268.3360927152318],
+        [44.70198675496689, 268.3360927152318],
+        [45.6953642384106, 267.3427152317881],
+        [45.6953642384106, 267.3427152317881],
+        [46.6887417218543, 267.3427152317881],
+        [47.682119205298015, 267.3427152317881],
+        [48.675496688741724, 266.34933774834434],
+        [48.675496688741724, 266.34933774834434],
+        [49.66887417218543, 266.34933774834434],
+        [50.66225165562914, 266.34933774834434],
+        [51.65562913907284, 265.35596026490066],
+        [52.64900662251656, 265.35596026490066],
+        [52.64900662251656, 265.35596026490066],
+        [53.64238410596026, 265.35596026490066],
+        [54.63576158940397, 264.362582781457],
+        [54.63576158940397, 264.362582781457],
+        [55.629139072847686, 264.362582781457],
+        [55.629139072847686, 264.362582781457],
+        [57.6158940397351, 263.36920529801324],
+        [57.6158940397351, 263.36920529801324],
+        [58.609271523178805, 263.36920529801324],
+        [58.609271523178805, 263.36920529801324],
+        [59.602649006622514, 262.37582781456956],
+        [60.59602649006623, 262.37582781456956],
+        [61.58940397350993, 262.37582781456956],
+        [62.58278145695365, 261.3824503311258],
+        [63.57615894039735, 261.3824503311258],
+        [64.56953642384106, 260.3890728476821],
+        [66.55629139072848, 259.3956953642384],
+        [67.54966887417218, 259.3956953642384],
+        [68.54304635761589, 259.3956953642384],
+        [69.5364238410596, 258.4023178807947],
+        [69.5364238410596, 258.4023178807947],
+        [70.52980132450331, 258.4023178807947],
+        [71.52317880794702, 258.4023178807947],
+        [71.52317880794702, 257.408940397351],
+        [71.52317880794702, 257.408940397351],
+        [72.51655629139073, 257.408940397351],
+        [72.51655629139073, 257.408940397351],
+        [72.51655629139073, 257.408940397351],
+        [73.50993377483444, 257.408940397351],
+        [73.50993377483444, 257.408940397351],
+        [73.50993377483444, 257.408940397351],
+        [74.50331125827815, 257.408940397351],
+        [76.49006622516558, 257.408940397351],
+        [77.48344370860927, 257.408940397351],
+        [79.47019867549669, 256.4155629139073],
+        [80.4635761589404, 256.4155629139073],
+        [82.45033112582782, 255.42218543046357],
+        [83.44370860927151, 255.42218543046357],
+        [84.43708609271523, 255.42218543046357],
+        [85.43046357615894, 255.42218543046357],
+        [85.43046357615894, 254.42880794701986],
+        [86.42384105960264, 254.42880794701986],
+        [86.42384105960264, 254.42880794701986],
+        [87.41721854304636, 254.42880794701986],
+        [87.41721854304636, 254.42880794701986],
+      ]
+
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should recognize line 1", () => {
+      const points = [
+        [380, 355],
+        [380, 356],
+        [381, 355],
+        [383, 354],
+        [386, 352],
+        [391, 349],
+        [395, 346],
+        [400, 343],
+        [405, 339],
+        [411, 335],
+        [416, 332],
+        [425, 325],
+        [433, 318],
+        [440, 312],
+        [447, 306],
+        [454, 300],
+        [462, 293],
+        [471, 283],
+        [479, 274],
+        [487, 266],
+        [498, 255],
+        [509, 244],
+        [520, 235],
+        [531, 226],
+        [539, 218],
+        [543, 215],
+        [550, 208],
+        [558, 203],
+        [563, 199],
+        [567, 196],
+        [571, 193],
+        [575, 190],
+        [577, 189],
+        [578, 188],
+        [579, 187],
+        [580, 187],
+        [580, 187],
+        [581, 187],
+        [581, 186],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should recognize line 2", () => {
+      const points = [
+        [648, 509],
+        [648, 509],
+        [648, 509],
+        [646, 509],
+        [641, 509],
+        [634, 509],
+        [628, 509],
+        [608, 509],
+        [591, 509],
+        [571, 509],
+        [554, 509],
+        [534, 509],
+        [513, 505],
+        [486, 499],
+        [462, 495],
+        [454, 494],
+        [433, 490],
+        [413, 488],
+        [396, 485],
+        [382, 485],
+        [368, 482],
+        [360, 482],
+        [356, 482],
+        [348, 479],
+        [341, 479],
+        [336, 478],
+        [331, 478],
+        [329, 478],
+        [327, 477],
+        [326, 476],
+        [326, 476],
+        [325, 476],
+        [325, 476],
+        [325, 476],
+        [325, 476],
+        [323, 476],
+        [322, 476],
+        [320, 476],
+        [319, 476],
+        [318, 476],
+        [316, 476],
+        [315, 475],
+        [315, 475],
+        [314, 475],
+        [314, 475],
+        [313, 475],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+
+    test("should recognize line 3", () => {
+      const points = [
+        [204, 590],
+        [205, 590],
+        [208, 584],
+        [219, 574],
+        [254, 534],
+        [276, 500],
+        [305, 456],
+        [334, 410],
+        [346, 388],
+        [376, 336],
+        [404, 284],
+        [430, 238],
+        [454, 197],
+        [458, 190],
+        [474, 160],
+        [483, 142],
+        [485, 138],
+        [492, 126],
+        [495, 121],
+        [498, 117],
+        [499, 115],
+        [500, 114],
+        [500, 114],
+        [500, 113],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.line)
+    })
+  })
+
+  describe("rectangles", () => {
+    test("should recognize simple rectangle", () => {
+      const points = [
+        [0, 0],
+        [5, 0],
+        [10, 0],
+        [10, 5],
+        [10, 10],
+        [5, 10],
+        [0, 10],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.rectangle)
+    })
+
+    test("should recognize rectangle with varying points", () => {
+      const points = [
+        [0, 0],
+        [5, 1],
+        [10, 0],
+        [10, 6],
+        [10, 10],
+        [6, 10],
+        [0, 10],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.rectangle)
+    })
+
+    test("should not recognize rectangle with non-rectangular points", () => {
+      const points = [
+        [5, 1],
+        [23, 0],
+        [10, 54],
+        [0, 10],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).not.toBe(Shapes.rectangle)
+    })
+
+    test("should not recognize unclosed rectangle", () => {
+      const points = [
+        [-10, -10],
+        [10, -10],
+        [10, 10],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).not.toBe(Shapes.rectangle)
+    })
+
+    test("should recognize almost-closed rectangle", () => {
+      const points = [
+        [0, 0],
+        [5, 0],
+        [10, 0],
+        [10, 5],
+        [10, 10],
+        [5, 10],
+        [0, 8],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.rectangle)
+    })
+
+    test("should recognize half-closed rectangle", () => {
+      const points = [
+        [380, 503],
+        [379, 503],
+        [379, 503],
+        [379, 498],
+        [379, 491],
+        [379, 471],
+        [379, 468],
+        [379, 457],
+        [379, 440],
+        [379, 428],
+        [379, 412],
+        [379, 398],
+        [379, 384],
+        [379, 373],
+        [379, 369],
+        [379, 361],
+        [379, 354],
+        [379, 349],
+        [379, 346],
+        [379, 344],
+        [379, 343],
+        [379, 342],
+        [379, 341],
+        [381, 340],
+        [385, 340],
+        [389, 340],
+        [398, 340],
+        [407, 340],
+        [418, 340],
+        [429, 340],
+        [440, 340],
+        [451, 340],
+        [463, 340],
+        [476, 342],
+        [488, 343],
+        [502, 345],
+        [515, 348],
+        [520, 349],
+        [531, 350],
+        [540, 351],
+        [549, 352],
+        [552, 353],
+        [557, 354],
+        [558, 355],
+        [560, 355],
+        [560, 355],
+        [560, 355],
+        [561, 355],
+        [561, 356],
+        [561, 356],
+        [561, 356],
+        [561, 357],
+        [561, 360],
+        [561, 363],
+        [561, 368],
+        [561, 377],
+        [561, 388],
+        [561, 399],
+        [561, 406],
+        [561, 414],
+        [561, 423],
+        [561, 432],
+        [561, 441],
+        [561, 447],
+        [561, 452],
+        [561, 459],
+        [561, 463],
+        [561, 468],
+        [561, 471],
+        [561, 475],
+        [561, 478],
+        [561, 479],
+        [561, 480],
+        [561, 480],
+        [561, 481],
+        [561, 482],
+        [561, 482],
+        [561, 483],
+        [560, 483],
+        [560, 483],
+        [558, 484],
+        [556, 485],
+        [551, 487],
+        [546, 488],
+        [540, 490],
+        [533, 492],
+        [522, 493],
+        [513, 494],
+        [502, 496],
+        [491, 497],
+        [480, 497],
+        [466, 499],
+        [452, 500],
+        [447, 500],
+        [436, 500],
+        [427, 501],
+        [418, 501],
+        [412, 503],
+        [407, 503],
+        [402, 504],
+        [400, 504],
+        [398, 504],
+        [398, 504],
+        [397, 504],
+        [396, 504],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.rectangle)
+    })
+
+    test("should recognize half-closed rectangle 2", () => {
+      const points = [
+        [294, 477],
+        [293, 477],
+        [293, 477],
+        [293, 473],
+        [293, 469],
+        [293, 465],
+        [293, 459],
+        [293, 455],
+        [293, 451],
+        [293, 444],
+        [293, 437],
+        [293, 431],
+        [293, 423],
+        [293, 414],
+        [293, 403],
+        [293, 394],
+        [293, 391],
+        [293, 384],
+        [293, 379],
+        [293, 376],
+        [293, 373],
+        [293, 372],
+        [293, 371],
+        [293, 370],
+        [293, 370],
+        [293, 369],
+        [294, 369],
+        [295, 368],
+        [298, 368],
+        [303, 367],
+        [308, 366],
+        [317, 364],
+        [328, 362],
+        [341, 360],
+        [358, 357],
+        [375, 355],
+        [392, 352],
+        [412, 350],
+        [436, 348],
+        [457, 346],
+        [480, 344],
+        [501, 342],
+        [518, 342],
+        [535, 340],
+        [539, 339],
+        [551, 339],
+        [559, 338],
+        [568, 337],
+        [573, 337],
+        [576, 337],
+        [578, 337],
+        [579, 337],
+        [579, 337],
+        [580, 337],
+        [580, 337],
+        [581, 337],
+        [581, 338],
+        [581, 341],
+        [581, 346],
+        [581, 349],
+        [581, 358],
+        [579, 366],
+        [578, 373],
+        [576, 382],
+        [575, 386],
+        [571, 403],
+        [571, 407],
+        [568, 420],
+        [567, 424],
+        [565, 430],
+        [562, 437],
+        [561, 442],
+        [559, 447],
+        [558, 450],
+        [557, 452],
+        [556, 454],
+        [556, 456],
+        [555, 458],
+        [555, 459],
+        [554, 460],
+        [554, 461],
+        [553, 462],
+        [553, 462],
+        [553, 463],
+        [552, 463],
+        [552, 463],
+        [552, 464],
+        [552, 464],
+        [551, 464],
+        [550, 465],
+        [549, 465],
+        [544, 466],
+        [541, 467],
+        [534, 468],
+        [527, 469],
+        [521, 470],
+        [512, 472],
+        [509, 472],
+        [500, 474],
+        [493, 475],
+        [485, 476],
+        [478, 477],
+        [471, 478],
+        [465, 479],
+        [460, 480],
+        [454, 481],
+        [450, 482],
+        [446, 483],
+        [442, 483],
+        [439, 483],
+        [437, 484],
+        [436, 484],
+        [435, 484],
+        [434, 484],
+        [433, 484],
+        [433, 484],
+        [433, 484],
+      ]
+      const result = recognizeFromPoints(points)
+      expect(result.shape).toBe(Shapes.rectangle)
+    })
+  })
+})

package-lock.json

@@ -14,15 +14,15 @@
       }
     },
     "@babel/core": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.7.4.tgz",
-      "integrity": "sha512-+bYbx56j4nYBmpsWtnPUsKW3NdnYxbqyfrP2w9wILBuHzdfIKz9prieZK0DFPyIzkjYVUe4QkusGL07r5pXznQ==",
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.7.7.tgz",
+      "integrity": "sha512-jlSjuj/7z138NLZALxVgrx13AOtqip42ATZP7+kYl53GvDV6+4dCek1mVUo8z8c8Xnw/mx2q3d9HWh3griuesQ==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.5.5",
-        "@babel/generator": "^7.7.4",
+        "@babel/generator": "^7.7.7",
         "@babel/helpers": "^7.7.4",
-        "@babel/parser": "^7.7.4",
+        "@babel/parser": "^7.7.7",
         "@babel/template": "^7.7.4",
         "@babel/traverse": "^7.7.4",
         "@babel/types": "^7.7.4",
@@ -44,6 +44,21 @@
             "ms": "^2.1.1"
           }
         },
+        "json5": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz",
+          "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==",
+          "dev": true,
+          "requires": {
+            "minimist": "^1.2.0"
+          }
+        },
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        },
         "ms": {
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
@@ -55,33 +70,19 @@
           "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
           "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
           "dev": true
-        },
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
         }
       }
     },
     "@babel/generator": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.7.4.tgz",
-      "integrity": "sha512-m5qo2WgdOJeyYngKImbkyQrnUN1mPceaG5BV+G0E3gWsa4l/jCSryWJdM2x8OuGAOyh+3d5pVYfZWCiNFtynxg==",
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.7.7.tgz",
+      "integrity": "sha512-/AOIBpHh/JU1l0ZFS4kiRCBnLi6OTHzh0RPk3h9isBxkkqELtQNFi1Vr/tiG9p1yfoUdKVwISuXWQR+hwwM4VQ==",
       "dev": true,
       "requires": {
         "@babel/types": "^7.7.4",
         "jsesc": "^2.5.1",
         "lodash": "^4.17.13",
         "source-map": "^0.5.0"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
-        }
       }
     },
     "@babel/helper-function-name": {
@@ -114,9 +115,9 @@
       }
     },
     "@babel/helper-module-transforms": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.7.4.tgz",
-      "integrity": "sha512-ehGBu4mXrhs0FxAqN8tWkzF8GSIGAiEumu4ONZ/hD9M88uHcD+Yu2ttKfOCgwzoesJOJrtQh7trI5YPbRtMmnA==",
+      "version": "7.7.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.7.5.tgz",
+      "integrity": "sha512-A7pSxyJf1gN5qXVcidwLWydjftUN878VkalhXX5iQDuGyiGK3sOrrKKHF4/A4fwHtnsotv/NipwAeLzY4KQPvw==",
       "dev": true,
       "requires": {
         "@babel/helper-module-imports": "^7.7.4",
@@ -188,9 +189,9 @@
       }
     },
     "@babel/parser": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.7.4.tgz",
-      "integrity": "sha512-jIwvLO0zCL+O/LmEJQjWA75MQTWwx3c3u2JOTDK5D3/9egrWRRA0/0hk9XXywYnXZVVpzrBYeIQTmhwUaePI9g==",
+      "version": "7.7.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.7.7.tgz",
+      "integrity": "sha512-WtTZMZAZLbeymhkd/sEaPD8IQyGAhmuTuvTzLiCFM7iXiVdY0gc0IaI+cW0fh1BnSMbJSzXX6/fHllgHKwHhXw==",
       "dev": true
     },
     "@babel/plugin-syntax-object-rest-spread": {
@@ -203,12 +204,12 @@
       }
     },
     "@babel/plugin-transform-modules-commonjs": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.7.4.tgz",
-      "integrity": "sha512-k8iVS7Jhc367IcNF53KCwIXtKAH7czev866ThsTgy8CwlXjnKZna2VHwChglzLleYrcHz1eQEIJlGRQxB53nqA==",
+      "version": "7.7.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.7.5.tgz",
+      "integrity": "sha512-9Cq4zTFExwFhQI6MT1aFxgqhIsMWQWDVwOgLzl7PTWJHsNaqFvklAU+Oz6AQLAS0dJKTwZSOCo20INwktxpi3Q==",
       "dev": true,
       "requires": {
-        "@babel/helper-module-transforms": "^7.7.4",
+        "@babel/helper-module-transforms": "^7.7.5",
         "@babel/helper-plugin-utils": "^7.0.0",
         "@babel/helper-simple-access": "^7.7.4",
         "babel-plugin-dynamic-import-node": "^2.3.0"
@@ -251,12 +252,6 @@
             "ms": "^2.1.1"
           }
         },
-        "globals": {
-          "version": "11.12.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
-          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
-          "dev": true
-        },
         "ms": {
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
@@ -294,6 +289,12 @@
         }
       }
     },
+    "@fortawesome/fontawesome-free": {
+      "version": "5.12.0",
+      "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-5.12.0.tgz",
+      "integrity": "sha512-vKDJUuE2GAdBERaQWmmtsciAMzjwNrROXA5KTGSZvayAsmuTGjam5z6QNqNPCwDfVljLWuov1nEC3mEQf/n6fQ==",
+      "dev": true
+    },
     "@jest/console": {
       "version": "24.9.0",
       "resolved": "https://registry.npmjs.org/@jest/console/-/console-24.9.0.tgz",
@@ -435,6 +436,12 @@
             "escape-string-regexp": "^1.0.5",
             "supports-color": "^5.3.0"
           }
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
         }
       }
     },
@@ -447,6 +454,14 @@
         "callsites": "^3.0.0",
         "graceful-fs": "^4.1.15",
         "source-map": "^0.6.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "@jest/test-result": {
@@ -506,6 +521,12 @@
             "escape-string-regexp": "^1.0.5",
             "supports-color": "^5.3.0"
           }
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
         }
       }
     },
@@ -578,9 +599,9 @@
       }
     },
     "@types/babel__generator": {
-      "version": "7.6.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.0.tgz",
-      "integrity": "sha512-c1mZUu4up5cp9KROs/QAw0gTeHrw/x7m52LcnvMxxOZ03DmLwPV0MlGmlgzV3cnSdjhJOZsj7E7FHeioai+egw==",
+      "version": "7.6.1",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.1.tgz",
+      "integrity": "sha512-bBKm+2VPJcMRVwNhxKu8W+5/zT7pwNEqeokFOmbvVSqGzFneNxYcEBro9Ac7/N9tlsaPYnZLK8J1LWKkMsLAew==",
       "dev": true,
       "requires": {
         "@babel/types": "^7.0.0"
@@ -678,9 +699,10 @@
       "dev": true
     },
     "@types/node": {
-      "version": "12.12.14",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.14.tgz",
-      "integrity": "sha512-u/SJDyXwuihpwjXy7hOOghagLEV1KdAST6syfnOk6QZAMzZuWZqXy5aYYZbh8Jdpd4escVFP0MvftHNDb9pruA=="
+      "version": "13.1.4",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-13.1.4.tgz",
+      "integrity": "sha512-Lue/mlp2egZJoHXZr4LndxDAd7i/7SQYhV0EjWfb/a4/OZ6tuVwMCVPiwkU5nsEipxEf7hmkSU7Em5VQ8P5NGA==",
+      "dev": true
     },
     "@types/stack-utils": {
       "version": "1.0.1",
@@ -689,9 +711,9 @@
       "dev": true
     },
     "@types/yargs": {
-      "version": "13.0.3",
-      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-13.0.3.tgz",
-      "integrity": "sha512-K8/LfZq2duW33XW/tFwEAfnZlqIfVsoyRB3kfXdPXYhl0nfM8mmh7GS0jg7WrX2Dgq/0Ha/pR1PaR+BvmWwjiQ==",
+      "version": "13.0.4",
+      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-13.0.4.tgz",
+      "integrity": "sha512-Ke1WmBbIkVM8bpvsNEcGgQM70XcEh/nbpxQhW7FhrsbCsXSY9BmLB1+LHtD7r9zrsOcFlLiF+a/UeJsdfw3C5A==",
       "dev": true,
       "requires": {
         "@types/yargs-parser": "*"
@@ -706,7 +728,8 @@
     "@ungap/event-target": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/@ungap/event-target/-/event-target-0.1.0.tgz",
-      "integrity": "sha512-W2oyj0Fe1w/XhPZjkI3oUcDUAmu5P4qsdT2/2S8aMhtAWM/CE/jYWtji0pKNPDfxLI75fa5gWSEmnynKMNP/oA=="
+      "integrity": "sha512-W2oyj0Fe1w/XhPZjkI3oUcDUAmu5P4qsdT2/2S8aMhtAWM/CE/jYWtji0pKNPDfxLI75fa5gWSEmnynKMNP/oA==",
+      "dev": true
     },
     "@webassemblyjs/ast": {
       "version": "1.8.5",
@@ -884,6 +907,230 @@
         "@xtuc/long": "4.2.2"
       }
     },
+    "@xmpp/base64": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/base64/-/base64-0.9.0.tgz",
+      "integrity": "sha512-/Naw/zQB3YryuQvSS3T3TwBV+z29Ox7RxfAs31foRcGblxw9Vkh4arTqwYpd49BLGbUzw+PBhpCgyJ4IrHPeFA==",
+      "requires": {
+        "base-64": "^0.1.0"
+      }
+    },
+    "@xmpp/client": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/client/-/client-0.9.2.tgz",
+      "integrity": "sha512-b/p+1RLiPhp3mngjkaKYyLcj0B6zwvQcV6K+JysJLz8kwevspIomlEO8dwHq3k2k3vX+Be6JPfREaTp+BjABtg==",
+      "requires": {
+        "@xmpp/client-core": "^0.9.2",
+        "@xmpp/iq": "^0.9.2",
+        "@xmpp/middleware": "^0.9.2",
+        "@xmpp/reconnect": "^0.9.0",
+        "@xmpp/resolve": "^0.9.2",
+        "@xmpp/resource-binding": "^0.9.2",
+        "@xmpp/sasl": "^0.9.2",
+        "@xmpp/sasl-anonymous": "^0.9.0",
+        "@xmpp/sasl-plain": "^0.9.0",
+        "@xmpp/sasl-scram-sha-1": "^0.9.0",
+        "@xmpp/session-establishment": "^0.9.2",
+        "@xmpp/starttls": "^0.9.2",
+        "@xmpp/stream-features": "^0.9.0",
+        "@xmpp/tcp": "^0.9.2",
+        "@xmpp/tls": "^0.9.2",
+        "@xmpp/websocket": "^0.9.2"
+      }
+    },
+    "@xmpp/client-core": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/client-core/-/client-core-0.9.2.tgz",
+      "integrity": "sha512-mNwg3FwB2OSFxjNY445SSL9OsrKefVGtQP1o3AuL26TjioGE+C8brijBvH+g4CM84G3/FF6aDOhvetp4fJJZcQ==",
+      "requires": {
+        "@xmpp/connection": "^0.9.2",
+        "@xmpp/jid": "^0.9.2",
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/connection": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/connection/-/connection-0.9.2.tgz",
+      "integrity": "sha512-Jlc39RhIYLqLLInV8pmUnNClaJgjh+ZZfwGrRvYTw9v0Pic7dOeE+cyT7ONZPjmfue4Jhqo8bRbKSrF7ezQbEA==",
+      "requires": {
+        "@xmpp/error": "^0.9.0",
+        "@xmpp/events": "^0.9.0",
+        "@xmpp/jid": "^0.9.2",
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/connection-tcp": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/connection-tcp/-/connection-tcp-0.9.2.tgz",
+      "integrity": "sha512-qdKp9vKprcaDcs/wdGPUc4GavaRNkoIH6q3PduMpIpF2CC8faQQTGO554i0k2VITxN4AyBIBIzPL5Iht/FEUSw==",
+      "requires": {
+        "@xmpp/connection": "^0.9.2",
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/error": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/error/-/error-0.9.0.tgz",
+      "integrity": "sha512-W8gqCwii+SmI8h1fx0HCFgfYMtrO0hjR2DeLHchn89F1x6o2fGisllLQ38vfCZWIqy3wXfLPuf5q6WM6nHe8gQ=="
+    },
+    "@xmpp/events": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/events/-/events-0.9.0.tgz",
+      "integrity": "sha512-ckOtr2u4NfsJxq7cl/6aZbQh3aXkrZHXOmm4Q+hdbUECZxpE1AxRu0QuxVS8yqmx+eVjGzOX98My4c0Dbe6CfQ==",
+      "requires": {
+        "events": "^3.0.0"
+      }
+    },
+    "@xmpp/id": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/id/-/id-0.9.0.tgz",
+      "integrity": "sha512-h7ycA0kDYM8fTObqtys92L3JTECnv6TUoUKP7Canq9xQP1k3K//ZMnMMFXc8NlU3Jl2U7V1Ny9zJlYM9gYv25w=="
+    },
+    "@xmpp/iq": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/iq/-/iq-0.9.2.tgz",
+      "integrity": "sha512-XCEuMj0JH41F7VgvKpF95lG4giXb/lyV0FbDmms3owCfWCEdaCxVJ8PzNZLq2rcUNCg/L1fvA+tUgZGqWMjnNw==",
+      "requires": {
+        "@xmpp/events": "^0.9.0",
+        "@xmpp/id": "^0.9.0",
+        "@xmpp/middleware": "^0.9.2",
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/jid": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/jid/-/jid-0.9.2.tgz",
+      "integrity": "sha512-mCWUhs/2C2/qB75m4x4VEEDMvs7ymcqZFjnrtgA3/i005+NLBHeZzzHiEo0n+VWVuyEE/6wrOmI/U2LkCGkEMA=="
+    },
+    "@xmpp/middleware": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/middleware/-/middleware-0.9.2.tgz",
+      "integrity": "sha512-ayvUm8+5gWQzq9iIh8YtzDENJAaZvIOSrmZtDfExKCewZlPSyqlMcMM96JqImyiIzXCj45q7qfaFmekZoYWt6g==",
+      "requires": {
+        "@xmpp/error": "^0.9.0",
+        "@xmpp/jid": "^0.9.2",
+        "@xmpp/xml": "^0.9.2",
+        "koa-compose": "^4.1.0"
+      }
+    },
+    "@xmpp/reconnect": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/reconnect/-/reconnect-0.9.0.tgz",
+      "integrity": "sha512-c7SicqcosnXpJ+s4jjGof94FzHEChKiInTf4Colh7WkVWwXtsGrRU1PMYIbX3P/58t5EqgZvfCYQrGjsWSB0kg==",
+      "requires": {
+        "@xmpp/events": "^0.9.0"
+      }
+    },
+    "@xmpp/resolve": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/resolve/-/resolve-0.9.2.tgz",
+      "integrity": "sha512-c0Ff0PSecGNnE2yOkDMd6IXJA9EFlKJWB2qfbfT+i24NObXjFsBeUnEdxlI0F4eFkAyxQYNvn8qPRX4bfPJlCw==",
+      "requires": {
+        "@xmpp/events": "^0.9.0",
+        "@xmpp/xml": "^0.9.2",
+        "node-fetch": "^2.3.0"
+      }
+    },
+    "@xmpp/resource-binding": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/resource-binding/-/resource-binding-0.9.2.tgz",
+      "integrity": "sha512-fwDY35KF6MmMSv+VJS+P5KlFd1tz5QCS/5KMo78egmlv6IiBNJILOsV36t7vnPFBj9yHNomv/lJAsNt/ApkkfQ==",
+      "requires": {
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/sasl": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/sasl/-/sasl-0.9.2.tgz",
+      "integrity": "sha512-58Fi0jkGB5o9JnRhF9SIJ3c6YdZsrxIAGMA2qksvTJfKdytx0OqmhoFU4mTxfV4fckvTOboEvYZlDSqQ26XPqQ==",
+      "requires": {
+        "@xmpp/base64": "^0.9.0",
+        "@xmpp/error": "^0.9.0",
+        "@xmpp/xml": "^0.9.2",
+        "saslmechanisms": "^0.1.1"
+      }
+    },
+    "@xmpp/sasl-anonymous": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/sasl-anonymous/-/sasl-anonymous-0.9.0.tgz",
+      "integrity": "sha512-F7t5LnSfmvybLBUsEOFkhvEJgY+CKdO09r5lmup5SvtYPIXMjLOb26qS+hn68woz2s1sk+tj5VUzEm/NbmfgAQ==",
+      "requires": {
+        "sasl-anonymous": "^0.1.0"
+      }
+    },
+    "@xmpp/sasl-plain": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/sasl-plain/-/sasl-plain-0.9.0.tgz",
+      "integrity": "sha512-7Jn34z88cy1khFYYFCnRQw0K10O+XxDKK13ImuOOS+tag+7ulvd2wT1cWJFcRIBsDvZJSqqROBfqXwHgd4PrYg==",
+      "requires": {
+        "sasl-plain": "^0.1.0"
+      }
+    },
+    "@xmpp/sasl-scram-sha-1": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/sasl-scram-sha-1/-/sasl-scram-sha-1-0.9.0.tgz",
+      "integrity": "sha512-AXV+Z5nwKKfkqg/XKsVi/fpJrJvhwUdZHxz84+cSskmfmD47cZw07eWkbFubs551qlAKeM/viSRE0WEaZqe4mA==",
+      "requires": {
+        "sasl-scram-sha-1": "^1.2.0"
+      }
+    },
+    "@xmpp/session-establishment": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/session-establishment/-/session-establishment-0.9.2.tgz",
+      "integrity": "sha512-p0WGTNxHusUOaNj72uVejAO94w8AvEwTMDfbtqHqMmotW4Lyw9xPgHgD7GFrCmU8S3OSWfyu36niXSgkrGJ2hg==",
+      "requires": {
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/starttls": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/starttls/-/starttls-0.9.2.tgz",
+      "integrity": "sha512-/rjpHb8RAN+LXug7aiMeDc8or/kBsy1Y8Cx/jVKN3aRTR6S35J/s+o9EB8apkZAPjNVO3pqcM3rh+K2wnA+f4w==",
+      "requires": {
+        "@xmpp/events": "^0.9.0",
+        "@xmpp/xml": "^0.9.2"
+      }
+    },
+    "@xmpp/stream-features": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@xmpp/stream-features/-/stream-features-0.9.0.tgz",
+      "integrity": "sha512-kO3sUE9+E1/0SoVe5KVbA/jrMIUp8vkk7kcEIzv3TBLQLlA0nnrbaTh3Wf1fvuOtJ8L2Tj1J06haLORY6h6rHQ=="
+    },
+    "@xmpp/tcp": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/tcp/-/tcp-0.9.2.tgz",
+      "integrity": "sha512-5sQPK6XDrEBxGGNTbyDlowBFIz04wSgnfmgw1jtz13v6fSK6ADypSX4sHNxBwhBa9RQ5kc/xEPWUU/p47AxCPQ==",
+      "requires": {
+        "@xmpp/connection-tcp": "^0.9.2"
+      }
+    },
+    "@xmpp/tls": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/tls/-/tls-0.9.2.tgz",
+      "integrity": "sha512-Iqp8xKFwV7pLYS0Bl5GAC0UtHYhGw9TZfKb4Nc4FDewkL74WdFsIcXqZuGo0Ry4xnJ8TBSkWi2oEE1hYGUytAw==",
+      "requires": {
+        "@xmpp/connection": "^0.9.2",
+        "@xmpp/connection-tcp": "^0.9.2"
+      }
+    },
+    "@xmpp/websocket": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/websocket/-/websocket-0.9.2.tgz",
+      "integrity": "sha512-6Bhv16psT4qZBhmhhd8T6wwCXGBhOkXCQCH2954gHqbMTKsZL3xkL6WM9O2doiHO1ffvLERy/ofOoPSLfOLPzA==",
+      "requires": {
+        "@xmpp/connection": "^0.9.2",
+        "@xmpp/xml": "^0.9.2",
+        "ws": "^7.0.0"
+      }
+    },
+    "@xmpp/xml": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xmpp/xml/-/xml-0.9.2.tgz",
+      "integrity": "sha512-xhPT3/EtTK0gsOLYyYmvoQncof1EQnE8P2eVBtUy/3Mt5FKhZI+gNsTkn+ORYjgkyHWfupIa9pN0/m7A89TCdA==",
+      "requires": {
+        "ltx": "^2.8.1"
+      }
+    },
     "@xtuc/ieee754": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
@@ -961,6 +1208,15 @@
       "resolved": "https://registry.npmjs.org/after/-/after-0.8.2.tgz",
       "integrity": "sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8="
     },
+    "agent-base": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-4.3.0.tgz",
+      "integrity": "sha512-salcGninV0nPrwpGNn4VTXBb1SOuXQBiqbrNXoeizJsHrsL6ERFM2Ne3JUSBWRE6aeNJI2ROP/WEEIDUiDe3cg==",
+      "dev": true,
+      "requires": {
+        "es6-promisify": "^5.0.0"
+      }
+    },
     "aggregate-error": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.0.1.tgz",
@@ -1009,6 +1265,12 @@
       "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=",
       "dev": true
     },
+    "ansi-escape": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-escape/-/ansi-escape-1.1.0.tgz",
+      "integrity": "sha1-ithZ6Epp4P+Rd5aUeTqS5OjAXpk=",
+      "dev": true
+    },
     "ansi-escapes": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.0.tgz",
@@ -1041,6 +1303,17 @@
       "requires": {
         "micromatch": "^3.1.4",
         "normalize-path": "^2.1.1"
+      },
+      "dependencies": {
+        "normalize-path": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
+          "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
+          "dev": true,
+          "requires": {
+            "remove-trailing-separator": "^1.0.1"
+          }
+        }
       }
     },
     "aproba": {
@@ -1088,6 +1361,12 @@
       "integrity": "sha1-bI4obRHtdoMn+OYuzuhzU8o+eLg=",
       "dev": true
     },
+    "array-flat-polyfill": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/array-flat-polyfill/-/array-flat-polyfill-1.0.1.tgz",
+      "integrity": "sha512-hfJmKupmQN0lwi0xG6FQ5U8Rd97RnIERplymOv/qpq8AoNKPPAnxJadjFA23FNWm88wykh9HmpLJUUwUtNU/iw==",
+      "dev": true
+    },
     "array-flatten": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
@@ -1120,9 +1399,9 @@
       "integrity": "sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog=="
     },
     "asar": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/asar/-/asar-2.0.1.tgz",
-      "integrity": "sha512-Vo9yTuUtyFahkVMFaI6uMuX6N7k5DWa6a/8+7ov0/f8Lq9TVR0tUjzSzxQSxT1Y+RJIZgnP7BVb6Uhi+9cjxqA==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/asar/-/asar-2.0.3.tgz",
+      "integrity": "sha512-QdHKO+HOYVtE4B/M3up3i4LSJeJgsa2CTVBrjBf9GgLUPGGUFZowcdJ5yE4gOJuRAHNdqB9JFeRfFfaOu5x8Rw==",
       "dev": true,
       "requires": {
         "chromium-pickle-js": "^0.2.0",
@@ -1208,7 +1487,8 @@
     "async": {
       "version": "0.9.2",
       "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz",
-      "integrity": "sha1-rqdNXmHB+JlhO/ZL2mbUx48v0X0="
+      "integrity": "sha1-rqdNXmHB+JlhO/ZL2mbUx48v0X0=",
+      "dev": true
     },
     "async-each": {
       "version": "1.0.3",
@@ -1242,7 +1522,8 @@
     "attachmediastream": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/attachmediastream/-/attachmediastream-2.1.0.tgz",
-      "integrity": "sha512-8zx/3Bwo/PxqwpNrEm2Zf9ZBCjfkLmLhS7lqzfP1eWH69iD/WyKWFpysben+gYxMSHcO9S94qvseGk4FVxba0g=="
+      "integrity": "sha512-8zx/3Bwo/PxqwpNrEm2Zf9ZBCjfkLmLhS7lqzfP1eWH69iD/WyKWFpysben+gYxMSHcO9S94qvseGk4FVxba0g==",
+      "dev": true
     },
     "aws-sign2": {
       "version": "0.7.0",
@@ -1353,15 +1634,23 @@
           "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
           "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
           "dev": true
-        },
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
         }
       }
     },
+    "babel-eslint": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/babel-eslint/-/babel-eslint-10.0.3.tgz",
+      "integrity": "sha512-z3U7eMY6r/3f3/JB9mTsLjyxrv0Yb1zb8PCWCLpguxfCzBIZUwy23R1t/XKewP+8mEN2Ck8Dtr4q20z6ce6SoA==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.0.0",
+        "@babel/parser": "^7.0.0",
+        "@babel/traverse": "^7.0.0",
+        "@babel/types": "^7.0.0",
+        "eslint-visitor-keys": "^1.0.0",
+        "resolve": "^1.12.0"
+      }
+    },
     "babel-generator": {
       "version": "6.26.1",
       "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz",
@@ -1383,12 +1672,6 @@
           "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz",
           "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=",
           "dev": true
-        },
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
         }
       }
     },
@@ -2133,12 +2416,6 @@
         "source-map-support": "^0.4.15"
       },
       "dependencies": {
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
-        },
         "source-map-support": {
           "version": "0.4.18",
           "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz",
@@ -2158,6 +2435,14 @@
       "requires": {
         "core-js": "^2.4.0",
         "regenerator-runtime": "^0.11.0"
+      },
+      "dependencies": {
+        "regenerator-runtime": {
+          "version": "0.11.1",
+          "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
+          "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
+          "dev": true
+        }
       }
     },
     "babel-template": {
@@ -2290,6 +2575,11 @@
         }
       }
     },
+    "base-64": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/base-64/-/base-64-0.1.0.tgz",
+      "integrity": "sha1-eAqZyE59YAJgNhURxId2E78k9rs="
+    },
     "base64-arraybuffer": {
       "version": "0.1.5",
       "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz",
@@ -2298,7 +2588,8 @@
     "base64-js": {
       "version": "1.3.1",
       "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz",
-      "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g=="
+      "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==",
+      "dev": true
     },
     "base64id": {
       "version": "2.0.0",
@@ -2352,15 +2643,30 @@
       "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==",
       "dev": true
     },
+    "bindings": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+      "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "file-uri-to-path": "1.0.0"
+      }
+    },
+    "bitwise-xor": {
+      "version": "0.0.0",
+      "resolved": "https://registry.npmjs.org/bitwise-xor/-/bitwise-xor-0.0.0.tgz",
+      "integrity": "sha1-BAqBcrW7jMVisLcRnyMLKhp4Dj0="
+    },
     "blob": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/blob/-/blob-0.0.5.tgz",
       "integrity": "sha512-gaqbzQPqOoamawKg0LGVd7SzLgXS+JH61oWprSLH+P+abTczqJbhTR8CmJ2u9/bUYNmHTGJx/UEmn6doAvvuig=="
     },
     "bluebird": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.1.tgz",
-      "integrity": "sha512-DdmyoGCleJnkbp3nkbxTLJ18rjDsE4yCggEwKNXkeV123sPNfOCYeDoeuOY+F2FrSjO1YXcTU+dsy96KMy+gcg==",
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
+      "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==",
       "dev": true
     },
     "bn.js": {
@@ -2387,9 +2693,9 @@
       }
     },
     "bowser": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.7.0.tgz",
-      "integrity": "sha512-aIlMvstvu8x+34KEiOHD3AsBgdrzg6sxALYiukOWhFvGMbQI6TRP/iY0LMhUrHs56aD6P1G0Z7h45PUJaa5m9w==",
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.8.1.tgz",
+      "integrity": "sha512-FxxltGKqMHkVa3KtpA+kdnxH0caHPDewccyrK3vW1bsMw6Zco4vRPmMunowX0pXlDZqhxkKSpToADQI2Sk4OeQ==",
       "dev": true
     },
     "brace-expansion": {
@@ -2563,6 +2869,7 @@
       "version": "5.4.3",
       "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.4.3.tgz",
       "integrity": "sha512-zvj65TkFeIt3i6aj5bIvJDzjjQQGs4o/sNoezg1F1kYap9Nu2jcUdpwzRSJTHMMzG0H7bZkn4rNQpImhuxWX2A==",
+      "dev": true,
       "requires": {
         "base64-js": "^1.0.2",
         "ieee754": "^1.1.4"
@@ -2574,6 +2881,12 @@
       "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
       "dev": true
     },
+    "buffer-shims": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/buffer-shims/-/buffer-shims-1.0.0.tgz",
+      "integrity": "sha1-mXjOMXOIxkmth5MCjDR37wRKi1E=",
+      "dev": true
+    },
     "buffer-xor": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz",
@@ -2695,15 +3008,16 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001012",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001012.tgz",
-      "integrity": "sha512-7RR4Uh04t9K1uYRWzOJmzplgEOAXbfK72oVNokCdMzA67trrhPzy93ahKk1AWHiA0c58tD2P+NHqxrA8FZ+Trg==",
+      "version": "1.0.30001019",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001019.tgz",
+      "integrity": "sha512-6ljkLtF1KM5fQ+5ZN0wuyVvvebJxgJPTmScOMaFuQN2QuOzvRJnWSKfzQskQU5IOU4Gap3zasYPIinzwUjoj/g==",
       "dev": true
     },
     "canvas-renderer": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/canvas-renderer/-/canvas-renderer-2.1.1.tgz",
-      "integrity": "sha512-/V0XetN7s1Mk3NO7x2wxPZYv0pLMQtGAhecuOuKR88beiYCUle1AbCcFZNLu+4NVzi9RVHS0rXtIgzPEaKidLw=="
+      "integrity": "sha512-/V0XetN7s1Mk3NO7x2wxPZYv0pLMQtGAhecuOuKR88beiYCUle1AbCcFZNLu+4NVzi9RVHS0rXtIgzPEaKidLw==",
+      "dev": true
     },
     "capture-exit": {
       "version": "2.0.0",
@@ -2745,9 +3059,9 @@
       },
       "dependencies": {
         "ansi-styles": {
-          "version": "4.2.0",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.0.tgz",
-          "integrity": "sha512-7kFQgnEaMdRtwf6uSfUnVr9gSGC7faurn+J/Mv90/W+iTtN0405/nLdopfMWwchyxhbGYl6TC4Sccn9TUkGAgg==",
+          "version": "4.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz",
+          "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==",
           "dev": true,
           "requires": {
             "@types/color-name": "^1.1.1",
@@ -2844,12 +3158,6 @@
               }
             }
           }
-        },
-        "normalize-path": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
-          "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
-          "dev": true
         }
       }
     },
@@ -2881,6 +3189,12 @@
           "integrity": "sha512-b0553uYA5YAEGgyYIGYROzKQ7X5RAqedkfjiZxwi0kL1g3bOaBNNZfYkzt/CL0umgD5wc9Jec2FbB98CjkMRvQ==",
           "dev": true
         },
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        },
         "ws": {
           "version": "3.3.3",
           "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz",
@@ -3017,9 +3331,9 @@
       "dev": true
     },
     "coffeescript": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/coffeescript/-/coffeescript-2.4.1.tgz",
-      "integrity": "sha512-34GV1aHrsMpTaO3KfMJL40ZNuvKDR/g98THHnE9bQj8HjMaZvSrLik99WWqyMhRtbe8V5hpx5iLgdcSvM/S2wg==",
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/coffeescript/-/coffeescript-2.5.0.tgz",
+      "integrity": "sha512-RgTKZhAeKVFuGtce/d3U1x1h5W75AoYFQszNlGrtSIbexC9jowaZo574uUvc9zoNQSDLMWXVtsus9usMtbFU+w==",
       "dev": true
     },
     "collection-visit": {
@@ -3119,6 +3433,13 @@
       "integrity": "sha512-ExO0774ikEObIAEV9kDo50o+79VCUdEB6n6lzKgGwupcVeRlhrj3qGAfwq8G6uBJjkqLrhT0qEYFcWng8z1z0g==",
       "requires": {
         "safe-buffer": "5.1.2"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+        }
       }
     },
     "content-type": {
@@ -3133,6 +3454,14 @@
       "dev": true,
       "requires": {
         "safe-buffer": "~5.1.1"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        }
       }
     },
     "cookie": {
@@ -3166,9 +3495,9 @@
       "dev": true
     },
     "core-js": {
-      "version": "2.6.10",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.10.tgz",
-      "integrity": "sha512-I39t74+4t+zau64EN1fE5v2W31Adtc/REhzWN+gWRRXg6WH5qAsZm62DHpQ1+Yhe4047T55jvzz7MUqF/dBBlA==",
+      "version": "2.6.11",
+      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.11.tgz",
+      "integrity": "sha512-5wjnpaT/3dV+XB4borEsnAYQchn00XSgTAWKDkEqv+K8KevjbzmofK6hfJ9TZIlpj2N0xQpazy7PiRQiWHqzWg==",
       "dev": true
     },
     "core-util-is": {
@@ -3281,6 +3610,32 @@
         }
       }
     },
+    "css-loader": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-3.4.1.tgz",
+      "integrity": "sha512-+ybmv7sVxxNEenQhkifQDvny/1iNQM7YooJbSfVUdQQvisyg1aKIqgGjCjoFSyVLJMp17z9rfZFQaR5HGHcMbw==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.3.1",
+        "cssesc": "^3.0.0",
+        "icss-utils": "^4.1.1",
+        "loader-utils": "^1.2.3",
+        "normalize-path": "^3.0.0",
+        "postcss": "^7.0.23",
+        "postcss-modules-extract-imports": "^2.0.0",
+        "postcss-modules-local-by-default": "^3.0.2",
+        "postcss-modules-scope": "^2.1.1",
+        "postcss-modules-values": "^3.0.0",
+        "postcss-value-parser": "^4.0.2",
+        "schema-utils": "^2.6.0"
+      }
+    },
+    "cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true
+    },
     "cssom": {
       "version": "0.3.8",
       "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz",
@@ -3311,12 +3666,14 @@
     "d3-path": {
       "version": "1.0.9",
       "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz",
-      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="
+      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==",
+      "dev": true
     },
     "d3-shape": {
       "version": "1.3.7",
       "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz",
       "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
+      "dev": true,
       "requires": {
         "d3-path": "1"
       }
@@ -3584,6 +3941,10 @@
       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.2.0.tgz",
       "integrity": "sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw=="
     },
+    "drawing-crdt": {
+      "version": "file:src/drawing-crdt/pkg",
+      "dev": true
+    },
     "duplexer": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
@@ -3624,9 +3985,9 @@
       "dev": true
     },
     "electron-to-chromium": {
-      "version": "1.3.314",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.314.tgz",
-      "integrity": "sha512-IKDR/xCxKFhPts7h+VaSXS02Z1mznP3fli1BbXWXeN89i2gCzKraU8qLpEid8YzKcmZdZD3Mly3cn5/lY9xsBQ==",
+      "version": "1.3.328",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.328.tgz",
+      "integrity": "sha512-x4XefnFxDxFwaQ01d/pppJP9meWhOIJ/gtI6/4jqkpsadq79uL7NYSaX64naLmJqvzUBjSrO3IM2+1b/W9KdPg==",
       "dev": true
     },
     "elegant-spinner": {
@@ -3739,14 +4100,6 @@
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
-        },
-        "ws": {
-          "version": "7.2.0",
-          "resolved": "https://registry.npmjs.org/ws/-/ws-7.2.0.tgz",
-          "integrity": "sha512-+SqNqFbwTm/0DC18KYzIsMTnEWpLwJsiasW/O17la4iDRRIO9uaHbvKiAS3AHgTiuuWerK/brj4O6MYZkei9xg==",
-          "requires": {
-            "async-limiter": "^1.0.0"
-          }
         }
       }
     },
@@ -3780,6 +4133,14 @@
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+        },
+        "ws": {
+          "version": "6.1.4",
+          "resolved": "https://registry.npmjs.org/ws/-/ws-6.1.4.tgz",
+          "integrity": "sha512-eqZfL+NE/YQc1/ZynhojeV8q+H050oR8AZ2uIev7RU10svA9ZnJUddHcOUZTJLinZ9yEfdA2kSATS2qZK5fhJA==",
+          "requires": {
+            "async-limiter": "~1.0.0"
+          }
         }
       }
     },
@@ -3846,21 +4207,22 @@
       }
     },
     "es-abstract": {
-      "version": "1.16.2",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.16.2.tgz",
-      "integrity": "sha512-jYo/J8XU2emLXl3OLwfwtuFfuF2w6DYPs+xy9ZfVyPkDcrauu6LYrw/q2TyCtrbc/KUdCiC5e9UajRhgNkVopA==",
+      "version": "1.17.0",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.0.tgz",
+      "integrity": "sha512-yYkE07YF+6SIBmg1MsJ9dlub5L48Ek7X0qz+c/CPCHS9EBXfESorzng4cJQjJW5/pB6vDF41u7F8vUhLVDqIug==",
       "dev": true,
       "requires": {
         "es-to-primitive": "^1.2.1",
         "function-bind": "^1.1.1",
         "has": "^1.0.3",
         "has-symbols": "^1.0.1",
-        "is-callable": "^1.1.4",
-        "is-regex": "^1.0.4",
+        "is-callable": "^1.1.5",
+        "is-regex": "^1.0.5",
         "object-inspect": "^1.7.0",
         "object-keys": "^1.1.1",
-        "string.prototype.trimleft": "^2.1.0",
-        "string.prototype.trimright": "^2.1.0"
+        "object.assign": "^4.1.0",
+        "string.prototype.trimleft": "^2.1.1",
+        "string.prototype.trimright": "^2.1.1"
       }
     },
     "es-to-primitive": {
@@ -3874,6 +4236,21 @@
         "is-symbol": "^1.0.2"
       }
     },
+    "es6-promise": {
+      "version": "4.2.8",
+      "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz",
+      "integrity": "sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==",
+      "dev": true
+    },
+    "es6-promisify": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz",
+      "integrity": "sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=",
+      "dev": true,
+      "requires": {
+        "es6-promise": "^4.0.3"
+      }
+    },
     "escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
@@ -3886,9 +4263,9 @@
       "dev": true
     },
     "escodegen": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.12.0.tgz",
-      "integrity": "sha512-TuA+EhsanGcme5T3R0L80u4t8CpbXQjegRmf7+FPTJrtCTErXFeelblRgHQa1FofEzqYYJmJ/OqjTwREp9qgmg==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.12.1.tgz",
+      "integrity": "sha512-Q8t2YZ+0e0pc7NRVj3B4tSQ9rim1oi4Fh46k2xhJ2qOiEwhQfdjyEQddWdj7ZFaKmU+5104vn1qrcjEPWq+bgQ==",
       "dev": true,
       "requires": {
         "esprima": "^3.1.3",
@@ -3903,13 +4280,20 @@
           "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz",
           "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=",
           "dev": true
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true,
+          "optional": true
         }
       }
     },
     "eslint": {
-      "version": "6.7.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-6.7.1.tgz",
-      "integrity": "sha512-UWzBS79pNcsDSxgxbdjkmzn/B6BhsXMfUaOHnNwyE8nD+Q6pyT96ow2MccVayUTV4yMid4qLhMiQaywctRkBLA==",
+      "version": "6.8.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-6.8.0.tgz",
+      "integrity": "sha512-K+Iayyo2LtyYhDSYwz5D5QdWw0hCacNzyq1Y821Xna2xSJj7cijoLLYmLxTQgcgZ9mC61nryMy9S7GRbYpI5Ig==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.0.0",
@@ -3971,18 +4355,27 @@
             "ms": "^2.1.1"
           }
         },
-        "ms": {
-          "version": "2.1.2",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+        "globals": {
+          "version": "12.3.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-12.3.0.tgz",
+          "integrity": "sha512-wAfjdLgFsPZsklLJvOBUBmzYE8/CwhEqSBEMRXA3qxIiNtyqvjYurAtIfDh6chlEPUfmTY3MnZh5Hfh4q0UlIw==",
+          "dev": true,
+          "requires": {
+            "type-fest": "^0.8.1"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
           "dev": true
         }
       }
     },
     "eslint-config-prettier": {
-      "version": "6.7.0",
-      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-6.7.0.tgz",
-      "integrity": "sha512-FamQVKM3jjUVwhG4hEMnbtsq7xOIDm+SY5iBPfR8gKsJoAB2IQnNF+bk1+8Fy44Nq7PPJaLvkRxILYdJWoguKQ==",
+      "version": "6.9.0",
+      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-6.9.0.tgz",
+      "integrity": "sha512-k4E14HBtcLv0uqThaI6I/n1LEqROp8XaPu6SO9Z32u5NlGRC07Enu1Bh2KEFw4FNHbekH8yzbIU9kUGxbiGmCA==",
       "dev": true,
       "requires": {
         "get-stdin": "^6.0.0"
@@ -4019,12 +4412,6 @@
       "integrity": "sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==",
       "dev": true
     },
-    "esm": {
-      "version": "3.2.25",
-      "resolved": "https://registry.npmjs.org/esm/-/esm-3.2.25.tgz",
-      "integrity": "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==",
-      "dev": true
-    },
     "esotope-hammerhead": {
       "version": "0.5.1",
       "resolved": "https://registry.npmjs.org/esotope-hammerhead/-/esotope-hammerhead-0.5.1.tgz",
@@ -4089,8 +4476,7 @@
     "events": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/events/-/events-3.0.0.tgz",
-      "integrity": "sha512-Dc381HFWJzEOhQ+d8pkNon++bk9h6cdAoAj4iE6Q4y6xgTzySWXlKn05/TVNpjnfRqi/X0EpJEJohPjNI3zpVA==",
-      "dev": true
+      "integrity": "sha512-Dc381HFWJzEOhQ+d8pkNon++bk9h6cdAoAj4iE6Q4y6xgTzySWXlKn05/TVNpjnfRqi/X0EpJEJohPjNI3zpVA=="
     },
     "evp_bytestokey": {
       "version": "1.0.3",
@@ -4222,6 +4608,13 @@
         "type-is": "~1.6.18",
         "utils-merge": "1.0.1",
         "vary": "~1.1.2"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+        }
       }
     },
     "extend": {
@@ -4327,6 +4720,18 @@
         }
       }
     },
+    "extract-zip": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-1.6.7.tgz",
+      "integrity": "sha1-qEC0uK9kAyZMjbV/Txp0Mz74H+k=",
+      "dev": true,
+      "requires": {
+        "concat-stream": "1.6.2",
+        "debug": "2.6.9",
+        "mkdirp": "0.5.1",
+        "yauzl": "2.4.1"
+      }
+    },
     "extsprintf": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz",
@@ -4377,9 +4782,9 @@
       }
     },
     "fast-json-stable-stringify": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz",
-      "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
       "dev": true
     },
     "fast-levenshtein": {
@@ -4388,6 +4793,12 @@
       "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
       "dev": true
     },
+    "fastbitset": {
+      "version": "0.2.8",
+      "resolved": "https://registry.npmjs.org/fastbitset/-/fastbitset-0.2.8.tgz",
+      "integrity": "sha512-OT0+4y2vxtkmvbxwfM3jbsylIQmB9xtgzraAiBcAz3xDLUG5Y1DwZrQNeKWt7myPsB5rHwdzenFXQq7YR+jMTQ==",
+      "dev": true
+    },
     "fastq": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.6.0.tgz",
@@ -4398,12 +4809,21 @@
       }
     },
     "fb-watchman": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.0.tgz",
-      "integrity": "sha1-VOmr99+i8mzZsWNsWIwa/AXeXVg=",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.1.tgz",
+      "integrity": "sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg==",
+      "dev": true,
+      "requires": {
+        "bser": "2.1.1"
+      }
+    },
+    "fd-slicer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.0.1.tgz",
+      "integrity": "sha1-i1vL2ewyfFBBv5qwI/1nUPEXfmU=",
       "dev": true,
       "requires": {
-        "bser": "^2.0.0"
+        "pend": "~1.2.0"
       }
     },
     "figgy-pudding": {
@@ -4430,6 +4850,23 @@
         "flat-cache": "^2.0.1"
       }
     },
+    "file-loader": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-5.0.2.tgz",
+      "integrity": "sha512-QMiQ+WBkGLejKe81HU8SZ9PovsU/5uaLo0JdTCEXOYv7i7jfAjHZi1tcwp9tSASJPOmmHZtbdCervFmXMH/Dcg==",
+      "dev": true,
+      "requires": {
+        "loader-utils": "^1.2.3",
+        "schema-utils": "^2.5.0"
+      }
+    },
+    "file-uri-to-path": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+      "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
+      "dev": true,
+      "optional": true
+    },
     "filesize": {
       "version": "3.6.1",
       "resolved": "https://registry.npmjs.org/filesize/-/filesize-3.6.1.tgz",
@@ -4440,6 +4877,7 @@
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/filetransfer/-/filetransfer-2.0.5.tgz",
       "integrity": "sha1-iHyARv5UbsiugVwzAaXDE1+js10=",
+      "dev": true,
       "requires": {
         "async": "^0.9.0",
         "iana-hashes": "^1.0.0",
@@ -4524,6 +4962,17 @@
         "flatted": "^2.0.0",
         "rimraf": "2.6.3",
         "write": "1.0.3"
+      },
+      "dependencies": {
+        "rimraf": {
+          "version": "2.6.3",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        }
       }
     },
     "flatted": {
@@ -4613,14 +5062,15 @@
       "dev": true
     },
     "fsevents": {
-      "version": "1.2.9",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.9.tgz",
-      "integrity": "sha512-oeyj2H3EjjonWcFjD5NvZNE9Rqe4UW+nQBU2HNeKw0koVLEFIhtyETyAakeAM3de7Z/SW5kcA+fZUait9EApnw==",
+      "version": "1.2.11",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.11.tgz",
+      "integrity": "sha512-+ux3lx6peh0BpvY0JebGyZoiR4D+oYzdPZMKJwkZ+sFkNJzpL7tXc/wehS49gUAxg3tmMHPHZkA8JU2rhhgDHw==",
       "dev": true,
       "optional": true,
       "requires": {
+        "bindings": "^1.5.0",
         "nan": "^2.12.1",
-        "node-pre-gyp": "^0.12.0"
+        "node-pre-gyp": "*"
       },
       "dependencies": {
         "abbrev": {
@@ -4668,7 +5118,7 @@
           }
         },
         "chownr": {
-          "version": "1.1.1",
+          "version": "1.1.3",
           "bundled": true,
           "dev": true,
           "optional": true
@@ -4698,7 +5148,7 @@
           "optional": true
         },
         "debug": {
-          "version": "4.1.1",
+          "version": "3.2.6",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4725,12 +5175,12 @@
           "optional": true
         },
         "fs-minipass": {
-          "version": "1.2.5",
+          "version": "1.2.7",
           "bundled": true,
           "dev": true,
           "optional": true,
           "requires": {
-            "minipass": "^2.2.1"
+            "minipass": "^2.6.0"
           }
         },
         "fs.realpath": {
@@ -4756,7 +5206,7 @@
           }
         },
         "glob": {
-          "version": "7.1.3",
+          "version": "7.1.6",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4785,7 +5235,7 @@
           }
         },
         "ignore-walk": {
-          "version": "3.0.1",
+          "version": "3.0.3",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4804,7 +5254,7 @@
           }
         },
         "inherits": {
-          "version": "2.0.3",
+          "version": "2.0.4",
           "bundled": true,
           "dev": true,
           "optional": true
@@ -4846,7 +5296,7 @@
           "optional": true
         },
         "minipass": {
-          "version": "2.3.5",
+          "version": "2.9.0",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4856,12 +5306,12 @@
           }
         },
         "minizlib": {
-          "version": "1.2.1",
+          "version": "1.3.3",
           "bundled": true,
           "dev": true,
           "optional": true,
           "requires": {
-            "minipass": "^2.2.1"
+            "minipass": "^2.9.0"
           }
         },
         "mkdirp": {
@@ -4874,24 +5324,24 @@
           }
         },
         "ms": {
-          "version": "2.1.1",
+          "version": "2.1.2",
           "bundled": true,
           "dev": true,
           "optional": true
         },
         "needle": {
-          "version": "2.3.0",
+          "version": "2.4.0",
           "bundled": true,
           "dev": true,
           "optional": true,
           "requires": {
-            "debug": "^4.1.0",
+            "debug": "^3.2.6",
             "iconv-lite": "^0.4.4",
             "sax": "^1.2.4"
           }
         },
         "node-pre-gyp": {
-          "version": "0.12.0",
+          "version": "0.14.0",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4905,7 +5355,7 @@
             "rc": "^1.2.7",
             "rimraf": "^2.6.1",
             "semver": "^5.3.0",
-            "tar": "^4"
+            "tar": "^4.4.2"
           }
         },
         "nopt": {
@@ -4919,13 +5369,22 @@
           }
         },
         "npm-bundled": {
-          "version": "1.0.6",
+          "version": "1.1.1",
+          "bundled": true,
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "npm-normalize-package-bin": "^1.0.1"
+          }
+        },
+        "npm-normalize-package-bin": {
+          "version": "1.0.1",
           "bundled": true,
           "dev": true,
           "optional": true
         },
         "npm-packlist": {
-          "version": "1.4.1",
+          "version": "1.4.7",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -4996,7 +5455,7 @@
           "optional": true
         },
         "process-nextick-args": {
-          "version": "2.0.0",
+          "version": "2.0.1",
           "bundled": true,
           "dev": true,
           "optional": true
@@ -5037,7 +5496,7 @@
           }
         },
         "rimraf": {
-          "version": "2.6.3",
+          "version": "2.7.1",
           "bundled": true,
           "dev": true,
           "optional": true,
@@ -5064,7 +5523,7 @@
           "optional": true
         },
         "semver": {
-          "version": "5.7.0",
+          "version": "5.7.1",
           "bundled": true,
           "dev": true,
           "optional": true
@@ -5117,18 +5576,18 @@
           "optional": true
         },
         "tar": {
-          "version": "4.4.8",
+          "version": "4.4.13",
           "bundled": true,
           "dev": true,
           "optional": true,
           "requires": {
             "chownr": "^1.1.1",
             "fs-minipass": "^1.2.5",
-            "minipass": "^2.3.4",
-            "minizlib": "^1.1.1",
+            "minipass": "^2.8.6",
+            "minizlib": "^1.2.1",
             "mkdirp": "^0.5.0",
             "safe-buffer": "^5.1.2",
-            "yallist": "^3.0.2"
+            "yallist": "^3.0.3"
           }
         },
         "util-deprecate": {
@@ -5153,7 +5612,7 @@
           "optional": true
         },
         "yallist": {
-          "version": "3.0.3",
+          "version": "3.1.1",
           "bundled": true,
           "dev": true,
           "optional": true
@@ -5279,13 +5738,10 @@
       }
     },
     "globals": {
-      "version": "12.3.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-12.3.0.tgz",
-      "integrity": "sha512-wAfjdLgFsPZsklLJvOBUBmzYE8/CwhEqSBEMRXA3qxIiNtyqvjYurAtIfDh6chlEPUfmTY3MnZh5Hfh4q0UlIw==",
-      "dev": true,
-      "requires": {
-        "type-fest": "^0.8.1"
-      }
+      "version": "11.12.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+      "dev": true
     },
     "globby": {
       "version": "9.2.0",
@@ -5318,12 +5774,12 @@
       "dev": true
     },
     "graphlib": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/graphlib/-/graphlib-2.1.7.tgz",
-      "integrity": "sha512-TyI9jIy2J4j0qgPmOOrHTCtpPqJGN/aurBwc6ZT+bRii+di1I+Wv3obRhVrmBEXet+qkMaEX67dXrwsd3QQM6w==",
+      "version": "2.1.8",
+      "resolved": "https://registry.npmjs.org/graphlib/-/graphlib-2.1.8.tgz",
+      "integrity": "sha512-jcLLfkpoVGmH7/InMC/1hIvOPSUh38oJtGhvrOFGzioE1DZ+0YW16RgmOJhHiuWTvGiJQ9Z1Ik43JvkRPRvE+A==",
       "dev": true,
       "requires": {
-        "lodash": "^4.17.5"
+        "lodash": "^4.17.15"
       }
     },
     "growly": {
@@ -5360,6 +5816,14 @@
         "optimist": "^0.6.1",
         "source-map": "^0.6.1",
         "uglify-js": "^3.1.4"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "har-schema": {
@@ -5382,6 +5846,7 @@
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/hark/-/hark-1.2.3.tgz",
       "integrity": "sha512-u68vz9SCa38ESiFJSDjqK8XbXqWzyot7Cj6Y2b6jk2NJ+II3MY2dIrLMg/kjtIAun4Y1DHF/20hfx4rq1G5GMg==",
+      "dev": true,
       "requires": {
         "wildemitter": "^1.2.0"
       }
@@ -5418,6 +5883,13 @@
       "integrity": "sha512-G1LWKhDSvhGeAQ8mPVQlqNcOB2sJdwATtZKl2pDKKHfpf/rYj24lkinxf69blJbnsvtqqNU+L3SL50vzZhXOnw==",
       "requires": {
         "isarray": "2.0.1"
+      },
+      "dependencies": {
+        "isarray": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz",
+          "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4="
+        }
       }
     },
     "has-cors": {
@@ -5579,6 +6051,13 @@
         "setprototypeof": "1.1.1",
         "statuses": ">= 1.5.0 < 2",
         "toidentifier": "1.0.0"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+          "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+        }
       }
     },
     "http-signature": {
@@ -5598,6 +6077,33 @@
       "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=",
       "dev": true
     },
+    "https-proxy-agent": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-3.0.1.tgz",
+      "integrity": "sha512-+ML2Rbh6DAuee7d07tYGEKOEi2voWPUGan+ExdPbPW6Z3svq+JCqr0v8WmKPOkz1vOVykPCBSuobe7G8GJUtVg==",
+      "dev": true,
+      "requires": {
+        "agent-base": "^4.3.0",
+        "debug": "^3.1.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "3.2.6",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
+          "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+          "dev": true
+        }
+      }
+    },
     "human-signals": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz",
@@ -5608,6 +6114,7 @@
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/humanhash/-/humanhash-1.0.4.tgz",
       "integrity": "sha512-fxOhEl/Ezv7PobYOTomDmQKWaSC0hk0mzl5et5McPtr+6LRBP7LYoeFLPjKW6xOSGmMNLj50BufrrgX+M5EvEA==",
+      "dev": true,
       "requires": {
         "uuid": "^3.3.2"
       }
@@ -5616,6 +6123,7 @@
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/iana-hashes/-/iana-hashes-1.1.0.tgz",
       "integrity": "sha512-dNFf+NqkF9M1lSluGyHGZNwxdIc8tL++n12Fp3/pcW85jN0ZePP78KugTA16J/paPNlGANE6kUlw81OQs4ulLQ==",
+      "dev": true,
       "requires": {
         "create-hash": "^1.1.0",
         "create-hmac": "^1.1.3",
@@ -5630,10 +6138,20 @@
         "safer-buffer": ">= 2.1.2 < 3"
       }
     },
+    "icss-utils": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-4.1.1.tgz",
+      "integrity": "sha512-4aFq7wvWyMHKgxsH8QQtGpvbASCf+eM3wPRLI6R+MgAnTCZ6STYsRvttLvRWK0Nfif5piF394St3HeJDaljGPA==",
+      "dev": true,
+      "requires": {
+        "postcss": "^7.0.14"
+      }
+    },
     "ieee754": {
       "version": "1.1.13",
       "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz",
-      "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg=="
+      "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==",
+      "dev": true
     },
     "iferr": {
       "version": "0.1.5",
@@ -5713,6 +6231,12 @@
         }
       }
     },
+    "indexes-of": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/indexes-of/-/indexes-of-1.0.1.tgz",
+      "integrity": "sha1-8w9xbI4r00bHtn0985FVZqfAVgc=",
+      "dev": true
+    },
     "indexof": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz",
@@ -5735,9 +6259,9 @@
       }
     },
     "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "ini": {
       "version": "1.3.5",
@@ -5746,9 +6270,9 @@
       "dev": true
     },
     "inquirer": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.0.0.tgz",
-      "integrity": "sha512-rSdC7zelHdRQFkWnhsMu2+2SO41mpv2oF2zy4tMhmiLWkcKbOAs87fWAJhVXttKVwhdZvymvnuM95EyEXg2/tQ==",
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.0.3.tgz",
+      "integrity": "sha512-+OiOVeVydu4hnCGLCSX+wedovR/Yzskv9BFqUNNKq9uU2qg7LCcCo3R86S2E7WLo0y/x2pnEZfZe1CoYnORUAw==",
       "dev": true,
       "requires": {
         "ansi-escapes": "^4.2.1",
@@ -5760,7 +6284,7 @@
         "lodash": "^4.17.15",
         "mute-stream": "0.0.8",
         "run-async": "^2.2.0",
-        "rxjs": "^6.4.0",
+        "rxjs": "^6.5.3",
         "string-width": "^4.1.0",
         "strip-ansi": "^5.1.0",
         "through": "^2.3.6"
@@ -5853,9 +6377,9 @@
       "dev": true
     },
     "is-callable": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz",
-      "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.5.tgz",
+      "integrity": "sha512-ESKv5sMCJB2jnHTWZ3O5itG+O128Hsus4K4Qh1h2/cgn2vbgnLSVqfV46AeJA9D5EeeLa9w81KUXMtn34zhX+Q==",
       "dev": true
     },
     "is-ci": {
@@ -5888,9 +6412,9 @@
       }
     },
     "is-date-object": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz",
-      "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz",
+      "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==",
       "dev": true
     },
     "is-descriptor": {
@@ -6032,12 +6556,12 @@
       "dev": true
     },
     "is-regex": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
-      "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz",
+      "integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==",
       "dev": true,
       "requires": {
-        "has": "^1.0.1"
+        "has": "^1.0.3"
       }
     },
     "is-stream": {
@@ -6080,9 +6604,10 @@
       "dev": true
     },
     "isarray": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz",
-      "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4="
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+      "dev": true
     },
     "isexe": {
       "version": "2.0.0",
@@ -6172,6 +6697,12 @@
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
           "dev": true
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
         }
       }
     },
@@ -6188,6 +6719,7 @@
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/jdenticon/-/jdenticon-2.2.0.tgz",
       "integrity": "sha512-WGqwpjN9pab/Sah9pGnFH5tQc3HF3WbLV/tPVbykvk5nuAkxG/zhzQYWC2owvpnS+/A0HmlSx35rtY8kyN+x7Q==",
+      "dev": true,
       "requires": {
         "@types/node": "*",
         "canvas-renderer": "~2.1.1"
@@ -6712,6 +7244,12 @@
             "escape-string-regexp": "^1.0.5",
             "supports-color": "^5.3.0"
           }
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
         }
       }
     },
@@ -6907,9 +7445,9 @@
       "dev": true
     },
     "json5": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz",
-      "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
+      "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
       "dev": true,
       "requires": {
         "minimist": "^1.2.0"
@@ -6947,6 +7485,11 @@
       "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
       "dev": true
     },
+    "koa-compose": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/koa-compose/-/koa-compose-4.1.0.tgz",
+      "integrity": "sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw=="
+    },
     "lcid": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/lcid/-/lcid-2.0.0.tgz",
@@ -6989,6 +7532,7 @@
     },
     "liowebrtc": {
       "version": "file:src/liowebrtc",
+      "dev": true,
       "requires": {
         "attachmediastream": "^2.1.0",
         "filetransfer": "^2.0.4",
@@ -7028,23 +7572,6 @@
         "big.js": "^5.2.2",
         "emojis-list": "^2.0.0",
         "json5": "^1.0.1"
-      },
-      "dependencies": {
-        "json5": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
-          "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
-          "dev": true,
-          "requires": {
-            "minimist": "^1.2.0"
-          }
-        },
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-          "dev": true
-        }
       }
     },
     "locate-path": {
@@ -7164,6 +7691,14 @@
       "integrity": "sha1-UczQtPwMhDWH16VwnOTTt2Kb7cU=",
       "dev": true
     },
+    "ltx": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/ltx/-/ltx-2.9.2.tgz",
+      "integrity": "sha512-llB7HflFhlfsYYT1SAe80elCBO5C20ryLdwPB/A/BZk38hhVeZztDlWQ9uTyvKNPX4aK6sA+JfS1f/mfzp5cxA==",
+      "requires": {
+        "inherits": "^2.0.4"
+      }
+    },
     "make-dir": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz",
@@ -7343,16 +7878,16 @@
       "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
     },
     "mime-db": {
-      "version": "1.42.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.42.0.tgz",
-      "integrity": "sha512-UbfJCR4UAVRNgMpfImz05smAXK7+c+ZntjaA26ANtkXLlOe947Aag5zdIcKQULAiF9Cq4WxBi9jUs5zkA84bYQ=="
+      "version": "1.43.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.43.0.tgz",
+      "integrity": "sha512-+5dsGEEovYbT8UY9yD7eE4XTc4UwJ1jBYlgaQQF38ENsKR3wj/8q8RFZrF9WIZpB2V1ArTVFUva8sAul1NzRzQ=="
     },
     "mime-types": {
-      "version": "2.1.25",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.25.tgz",
-      "integrity": "sha512-5KhStqB5xpTAeGqKBAMgwaYMnQik7teQN4IAzC7npDv6kzeU6prfkR67bc87J1kWMPGkoaZSq1npmexMgkmEVg==",
+      "version": "2.1.26",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.26.tgz",
+      "integrity": "sha512-01paPWYgLrkqAyrlDorC1uDwl2p3qZT7yl806vW7DvDoxwXi46jsjFbg+WdwotBIk6/MbEhO/dh5aZ5sNj/dWQ==",
       "requires": {
-        "mime-db": "1.42.0"
+        "mime-db": "1.43.0"
       }
     },
     "mimic-fn": {
@@ -7439,7 +7974,8 @@
     "mockconsole": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/mockconsole/-/mockconsole-0.0.1.tgz",
-      "integrity": "sha1-1ip+2FUwlkq80k7bnzD6WLvOVsY="
+      "integrity": "sha1-1ip+2FUwlkq80k7bnzD6WLvOVsY=",
+      "dev": true
     },
     "moment": {
       "version": "2.24.0",
@@ -7539,6 +8075,11 @@
       "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
       "dev": true
     },
+    "node-fetch": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.0.tgz",
+      "integrity": "sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA=="
+    },
     "node-int64": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
@@ -7587,12 +8128,6 @@
             "isarray": "^1.0.0"
           }
         },
-        "isarray": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-          "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
-          "dev": true
-        },
         "punycode": {
           "version": "1.4.1",
           "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
@@ -7660,13 +8195,10 @@
       }
     },
     "normalize-path": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
-      "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
-      "dev": true,
-      "requires": {
-        "remove-trailing-separator": "^1.0.1"
-      }
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true
     },
     "npm-run-all": {
       "version": "4.1.5",
@@ -7801,13 +8333,13 @@
       }
     },
     "object.getownpropertydescriptors": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz",
-      "integrity": "sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz",
+      "integrity": "sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg==",
       "dev": true,
       "requires": {
-        "define-properties": "^1.1.2",
-        "es-abstract": "^1.5.1"
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.17.0-next.1"
       }
     },
     "object.pick": {
@@ -7938,9 +8470,9 @@
       "dev": true
     },
     "p-limit": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz",
-      "integrity": "sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==",
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.2.tgz",
+      "integrity": "sha512-WGR+xHecKTr7EbUEhyLSh5Dube9JtdiG78ufaeLxTgpudf/20KqyMioIUZJAezlTIi6evxuoUs9YXc11cU+yzQ==",
       "dev": true,
       "requires": {
         "p-try": "^2.0.0"
@@ -7976,7 +8508,8 @@
     "pako": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.10.tgz",
-      "integrity": "sha512-0DTvPVU3ed8+HNXOu5Bs+o//Mbdj9VNQMUOe9oKCwh8l0GNwpTDMKCWbRjgtD291AWnkAgkqA/LOnQS8AmS1tw=="
+      "integrity": "sha512-0DTvPVU3ed8+HNXOu5Bs+o//Mbdj9VNQMUOe9oKCwh8l0GNwpTDMKCWbRjgtD291AWnkAgkqA/LOnQS8AmS1tw==",
+      "dev": true
     },
     "parallel-transform": {
       "version": "1.2.0",
@@ -8022,6 +8555,12 @@
         "json-parse-better-errors": "^1.0.1"
       }
     },
+    "parse-ms": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-1.0.1.tgz",
+      "integrity": "sha1-VjRtR0nXjyNDDKDHE4UK75GqNh0=",
+      "dev": true
+    },
     "parse-passwd": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz",
@@ -8136,6 +8675,12 @@
         "sha.js": "^2.4.8"
       }
     },
+    "pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha1-elfrVQpng/kRUzH89GY9XI4AelA=",
+      "dev": true
+    },
     "performance-now": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
@@ -8143,9 +8688,9 @@
       "dev": true
     },
     "picomatch": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.1.1.tgz",
-      "integrity": "sha512-OYMyqkKzK7blWO/+XZYP6w8hH0LDvkBvdvKukti+7kqYFCiEAk+gI3DWnryapc0Dau05ugGTy0foQ6mqn4AHYA==",
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz",
+      "integrity": "sha512-ISBaA8xQNmwELC7eOjqFKMESB2VIqt4PPDD0nsS95b/9dZXvVKOlz9keMSnoGGKcOHXfTvDD6WMaRoSc9UuhRA==",
       "dev": true
     },
     "pidtree": {
@@ -8211,61 +8756,179 @@
       "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
       "dev": true
     },
-    "prelude-ls": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
-      "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
-      "dev": true
-    },
-    "prettier": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.19.1.tgz",
-      "integrity": "sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==",
-      "dev": true
-    },
-    "pretty-bytes": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.3.0.tgz",
-      "integrity": "sha512-hjGrh+P926p4R4WbaB6OckyRtO0F0/lQBiT+0gnxjV+5kjPBrfVBFCsCLbMqVQeydvIoouYTCmmEURiH3R1Bdg=="
-    },
-    "pretty-format": {
-      "version": "24.9.0",
-      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-24.9.0.tgz",
-      "integrity": "sha512-00ZMZUiHaJrNfk33guavqgvfJS30sLYf0f8+Srklv0AMPodGGHcoHgksZ3OThYnIvOd+8yMCn0YiEOogjlgsnA==",
+    "postcss": {
+      "version": "7.0.26",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-7.0.26.tgz",
+      "integrity": "sha512-IY4oRjpXWYshuTDFxMVkJDtWIk2LhsTlu8bZnbEJA4+bYT16Lvpo8Qv6EvDumhYRgzjZl489pmsY3qVgJQ08nA==",
       "dev": true,
       "requires": {
-        "@jest/types": "^24.9.0",
-        "ansi-regex": "^4.0.0",
-        "ansi-styles": "^3.2.0",
-        "react-is": "^16.8.4"
+        "chalk": "^2.4.2",
+        "source-map": "^0.6.1",
+        "supports-color": "^6.1.0"
       },
       "dependencies": {
-        "ansi-regex": {
-          "version": "4.1.0",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
-          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
-          "dev": true
-        }
-      }
-    },
-    "private": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
-      "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
-      "dev": true
-    },
-    "process": {
-      "version": "0.11.10",
-      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
-      "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=",
-      "dev": true
-    },
-    "process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
-      "dev": true
-    },
+        "chalk": {
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^3.2.1",
+            "escape-string-regexp": "^1.0.5",
+            "supports-color": "^5.3.0"
+          },
+          "dependencies": {
+            "supports-color": {
+              "version": "5.5.0",
+              "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+              "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+              "dev": true,
+              "requires": {
+                "has-flag": "^3.0.0"
+              }
+            }
+          }
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        },
+        "supports-color": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz",
+          "integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "postcss-modules-extract-imports": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-2.0.0.tgz",
+      "integrity": "sha512-LaYLDNS4SG8Q5WAWqIJgdHPJrDDr/Lv775rMBFUbgjTz6j34lUznACHcdRWroPvXANP2Vj7yNK57vp9eFqzLWQ==",
+      "dev": true,
+      "requires": {
+        "postcss": "^7.0.5"
+      }
+    },
+    "postcss-modules-local-by-default": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-3.0.2.tgz",
+      "integrity": "sha512-jM/V8eqM4oJ/22j0gx4jrp63GSvDH6v86OqyTHHUvk4/k1vceipZsaymiZ5PvocqZOl5SFHiFJqjs3la0wnfIQ==",
+      "dev": true,
+      "requires": {
+        "icss-utils": "^4.1.1",
+        "postcss": "^7.0.16",
+        "postcss-selector-parser": "^6.0.2",
+        "postcss-value-parser": "^4.0.0"
+      }
+    },
+    "postcss-modules-scope": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-2.1.1.tgz",
+      "integrity": "sha512-OXRUPecnHCg8b9xWvldG/jUpRIGPNRka0r4D4j0ESUU2/5IOnpsjfPPmDprM3Ih8CgZ8FXjWqaniK5v4rWt3oQ==",
+      "dev": true,
+      "requires": {
+        "postcss": "^7.0.6",
+        "postcss-selector-parser": "^6.0.0"
+      }
+    },
+    "postcss-modules-values": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-3.0.0.tgz",
+      "integrity": "sha512-1//E5jCBrZ9DmRX+zCtmQtRSV6PV42Ix7Bzj9GbwJceduuf7IqP8MgeTXuRDHOWj2m0VzZD5+roFWDuU8RQjcg==",
+      "dev": true,
+      "requires": {
+        "icss-utils": "^4.0.0",
+        "postcss": "^7.0.6"
+      }
+    },
+    "postcss-selector-parser": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.2.tgz",
+      "integrity": "sha512-36P2QR59jDTOAiIkqEprfJDsoNrvwFei3eCqKd1Y0tUsBimsq39BLp7RD+JWny3WgB1zGhJX8XVePwm9k4wdBg==",
+      "dev": true,
+      "requires": {
+        "cssesc": "^3.0.0",
+        "indexes-of": "^1.0.1",
+        "uniq": "^1.0.1"
+      }
+    },
+    "postcss-value-parser": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.0.2.tgz",
+      "integrity": "sha512-LmeoohTpp/K4UiyQCwuGWlONxXamGzCMtFxLq4W1nZVGIQLYvMCJx3yAF9qyyuFpflABI9yVdtJAqbihOsCsJQ==",
+      "dev": true
+    },
+    "prelude-ls": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
+      "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
+      "dev": true
+    },
+    "prettier": {
+      "version": "1.19.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.19.1.tgz",
+      "integrity": "sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==",
+      "dev": true
+    },
+    "pretty-bytes": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.3.0.tgz",
+      "integrity": "sha512-hjGrh+P926p4R4WbaB6OckyRtO0F0/lQBiT+0gnxjV+5kjPBrfVBFCsCLbMqVQeydvIoouYTCmmEURiH3R1Bdg==",
+      "dev": true
+    },
+    "pretty-format": {
+      "version": "24.9.0",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-24.9.0.tgz",
+      "integrity": "sha512-00ZMZUiHaJrNfk33guavqgvfJS30sLYf0f8+Srklv0AMPodGGHcoHgksZ3OThYnIvOd+8yMCn0YiEOogjlgsnA==",
+      "dev": true,
+      "requires": {
+        "@jest/types": "^24.9.0",
+        "ansi-regex": "^4.0.0",
+        "ansi-styles": "^3.2.0",
+        "react-is": "^16.8.4"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        }
+      }
+    },
+    "pretty-ms": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-3.2.0.tgz",
+      "integrity": "sha512-ZypexbfVUGTFxb0v+m1bUyy92DHe5SyYlnyY0msyms5zd3RwyvNgyxZZsXXgoyzlxjx5MiqtXUdhUfvQbe0A2Q==",
+      "dev": true,
+      "requires": {
+        "parse-ms": "^1.0.0"
+      }
+    },
+    "private": {
+      "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
+      "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
+      "dev": true
+    },
+    "process": {
+      "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=",
+      "dev": true
+    },
+    "process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "dev": true
+    },
     "progress": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
@@ -8306,6 +8969,12 @@
         "ipaddr.js": "1.9.0"
       }
     },
+    "proxy-from-env": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.0.0.tgz",
+      "integrity": "sha1-M8UDmPcOp+uW0h97gXYwpVeRx+4=",
+      "dev": true
+    },
     "prr": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz",
@@ -8313,9 +8982,9 @@
       "dev": true
     },
     "psl": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.4.0.tgz",
-      "integrity": "sha512-HZzqCGPecFLyoRj5HLfuDSKYTJkAfB5thKBIkRHtGjWwY7p1dAyveIbXIq4tO0KYfDF2tHqPUgY9SDnGm00uFw==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.7.0.tgz",
+      "integrity": "sha512-5NsSEDv8zY70ScRnOTn7bK7eanl2MvFrOrS/R6x+dBt5g1ghnj9Zv90kO8GwT8gxcu2ANyFprnFYB85IogIJOQ==",
       "dev": true
     },
     "public-encrypt": {
@@ -8371,6 +9040,54 @@
       "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
       "dev": true
     },
+    "puppeteer-core": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-2.0.0.tgz",
+      "integrity": "sha512-xgg8hLm7VIiwoYRZtgXNy0gf9IKCA/WyT5Rm5RqkDc7mm4bJMeESmzP+YWyl+X/c1CSOuCy4WWnnC+9T+DKgCQ==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.1.0",
+        "extract-zip": "^1.6.6",
+        "https-proxy-agent": "^3.0.0",
+        "mime": "^2.0.3",
+        "progress": "^2.0.1",
+        "proxy-from-env": "^1.0.0",
+        "rimraf": "^2.6.1",
+        "ws": "^6.1.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
+          "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "mime": {
+          "version": "2.4.4",
+          "resolved": "https://registry.npmjs.org/mime/-/mime-2.4.4.tgz",
+          "integrity": "sha512-LRxmNwziLPT828z+4YkNzloCFC2YM4wrB99k+AV5ZbEyfGNWfG8SO1FUXLmLDBSo89NrJZ4DIWeLjy1CHGhMGA==",
+          "dev": true
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+          "dev": true
+        },
+        "ws": {
+          "version": "6.2.1",
+          "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.1.tgz",
+          "integrity": "sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==",
+          "dev": true,
+          "requires": {
+            "async-limiter": "~1.0.0"
+          }
+        }
+      }
+    },
     "qrcode-terminal": {
       "version": "0.10.0",
       "resolved": "https://registry.npmjs.org/qrcode-terminal/-/qrcode-terminal-0.10.0.tgz",
@@ -8428,6 +9145,12 @@
         "unpipe": "1.0.0"
       }
     },
+    "re-emitter": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/re-emitter/-/re-emitter-1.1.3.tgz",
+      "integrity": "sha1-+p4xn/3u6zWycpbvDz03TawvUqc=",
+      "dev": true
+    },
     "react-is": {
       "version": "16.12.0",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.12.0.tgz",
@@ -8465,9 +9188,9 @@
       }
     },
     "readable-stream": {
-      "version": "2.3.6",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
-      "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
+      "version": "2.3.7",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
+      "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
       "dev": true,
       "requires": {
         "core-util-is": "~1.0.0",
@@ -8479,10 +9202,10 @@
         "util-deprecate": "~1.0.1"
       },
       "dependencies": {
-        "isarray": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-          "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
           "dev": true
         }
       }
@@ -8513,12 +9236,6 @@
       "integrity": "sha512-1G6jJVDWrt0rK99kBjvEtziZNCICAuvIPkSiUFIQxVP06RCVpq3dmDo2oi6ABpYaDYaTRr67BEhL8r1wgEZZKg==",
       "dev": true
     },
-    "regenerator-runtime": {
-      "version": "0.11.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
-      "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
-      "dev": true
-    },
     "regenerator-transform": {
       "version": "0.10.1",
       "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz",
@@ -8698,9 +9415,9 @@
       "dev": true
     },
     "resolve": {
-      "version": "1.13.1",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.13.1.tgz",
-      "integrity": "sha512-CxqObCX8K8YtAhOBRg+lrcdn+LK+WYOS8tSjqSFbjtrI5PnS63QPhZl4+yKfrU9tdsbMu9Anr/amegT87M9Z6w==",
+      "version": "1.14.2",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.14.2.tgz",
+      "integrity": "sha512-EjlOBLBO1kxsUxsKjLt7TAECyKW6fOh1VRkykQkKGzcBbjjPIxBqGh0jf7GJ3k/f5mxMqW3htMD3WdTUVtW8HQ==",
       "dev": true,
       "requires": {
         "path-parse": "^1.0.6"
@@ -8781,9 +9498,9 @@
       "dev": true
     },
     "rimraf": {
-      "version": "2.6.3",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
-      "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz",
+      "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
       "dev": true,
       "requires": {
         "glob": "^7.1.3"
@@ -8806,6 +9523,7 @@
     },
     "rtcpeerconnection": {
       "version": "file:src/rtcpeerconnection",
+      "dev": true,
       "requires": {
         "lodash.clonedeep": "^4.3.2",
         "sdp-jingle-json": "^3.0.0",
@@ -8815,17 +9533,20 @@
         "lodash.clonedeep": {
           "version": "4.5.0",
           "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
-          "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8="
+          "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=",
+          "dev": true
         },
         "sdp-jingle-json": {
           "version": "3.1.0",
           "resolved": "https://registry.npmjs.org/sdp-jingle-json/-/sdp-jingle-json-3.1.0.tgz",
-          "integrity": "sha512-Uu+FelZD/edNoOc64NwQP8jjbBVMggAaErGU+2cSxPZgyReJTtqtp5287p2vu7bHubERxEbiW0H1pC2fnH5GEA=="
+          "integrity": "sha512-Uu+FelZD/edNoOc64NwQP8jjbBVMggAaErGU+2cSxPZgyReJTtqtp5287p2vu7bHubERxEbiW0H1pC2fnH5GEA==",
+          "dev": true
         },
         "wildemitter": {
           "version": "1.2.1",
           "resolved": "https://registry.npmjs.org/wildemitter/-/wildemitter-1.2.1.tgz",
-          "integrity": "sha512-UMmSUoIQSir+XbBpTxOTS53uJ8s/lVhADCkEbhfRjUGFDPme/XGOb0sBWLx5sTz7Wx/2+TlAw1eK9O5lw5PiEw=="
+          "integrity": "sha512-UMmSUoIQSir+XbBpTxOTS53uJ8s/lVhADCkEbhfRjUGFDPme/XGOb0sBWLx5sTz7Wx/2+TlAw1eK9O5lw5PiEw==",
+          "dev": true
         }
       }
     },
@@ -8833,6 +9554,7 @@
       "version": "1.2.15",
       "resolved": "https://registry.npmjs.org/rtcpeerconnection-shim/-/rtcpeerconnection-shim-1.2.15.tgz",
       "integrity": "sha512-C6DxhXt7bssQ1nHb154lqeL0SXz5Dx4RczXZu2Aa/L1NJFnEVDxFwCBo3fqtuljhHIGceg5JKBV4XJ0gW5JKyw==",
+      "dev": true,
       "requires": {
         "sdp": "^2.6.0"
       }
@@ -8862,18 +9584,18 @@
       }
     },
     "rxjs": {
-      "version": "6.5.3",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.3.tgz",
-      "integrity": "sha512-wuYsAYYFdWTAnAaPoKGNhfpWwKZbJW+HgAJ+mImp+Epl7BG8oNWBCTyRM8gba9k4lk8BgWdoYm21Mo/RYhhbgA==",
+      "version": "6.5.4",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.4.tgz",
+      "integrity": "sha512-naMQXcgEo3csAEGvw/NydRA0fuS2nDZJiw1YUWFKU7aPPAPGZEsD4Iimit96qwCieH6y614MCLYwdkrWx7z/7Q==",
       "dev": true,
       "requires": {
         "tslib": "^1.9.0"
       }
     },
     "safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.0.tgz",
+      "integrity": "sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg=="
     },
     "safe-regex": {
       "version": "1.1.0",
@@ -8923,6 +9645,32 @@
         "truncate-utf8-bytes": "^1.0.0"
       }
     },
+    "sasl-anonymous": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/sasl-anonymous/-/sasl-anonymous-0.1.0.tgz",
+      "integrity": "sha1-9UTH6CTfKkDZrUczgpVyzI2e1aU="
+    },
+    "sasl-plain": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/sasl-plain/-/sasl-plain-0.1.0.tgz",
+      "integrity": "sha1-zxRefAIiK2TWDAgG2c0q5TgEJsw="
+    },
+    "sasl-scram-sha-1": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/sasl-scram-sha-1/-/sasl-scram-sha-1-1.2.1.tgz",
+      "integrity": "sha1-2I1R/qoP8yDY6x1vx1ZXZT+dzUs=",
+      "requires": {
+        "bitwise-xor": "0.0.0",
+        "create-hash": "^1.1.0",
+        "create-hmac": "^1.1.3",
+        "randombytes": "^2.0.1"
+      }
+    },
+    "saslmechanisms": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/saslmechanisms/-/saslmechanisms-0.1.1.tgz",
+      "integrity": "sha1-R4vhQpUA/PqngL6IszQ87X0qkYI="
+    },
     "sax": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
@@ -8930,20 +9678,20 @@
       "dev": true
     },
     "schema-utils": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz",
-      "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.6.1.tgz",
+      "integrity": "sha512-0WXHDs1VDJyo+Zqs9TKLKyD/h7yDpHUhEFsM2CzkICFdoX1av+GBq/J2xRTFfsQO5kBfhZzANf2VcIm84jqDbg==",
       "dev": true,
       "requires": {
-        "ajv": "^6.1.0",
-        "ajv-errors": "^1.0.0",
-        "ajv-keywords": "^3.1.0"
+        "ajv": "^6.10.2",
+        "ajv-keywords": "^3.4.1"
       }
     },
     "sdp": {
-      "version": "2.10.0",
-      "resolved": "https://registry.npmjs.org/sdp/-/sdp-2.10.0.tgz",
-      "integrity": "sha512-H+VjfyQpRz9GezhshJmkXTtCAT9/2g9az3GFDPYfGOz0eAOQU1fCrL3S9Dq/eUT9FtOyLi/czdR9PzK3fKUYOQ=="
+      "version": "2.11.2",
+      "resolved": "https://registry.npmjs.org/sdp/-/sdp-2.11.2.tgz",
+      "integrity": "sha512-Oly+pE5hwmshcyNCEep4AZ6P7C1UTAzqsXhPRefYVFzxsCcVdHFBqmi/b+KON0uoKXyQvf8avUT4Z2P2kmCfiQ==",
+      "dev": true
     },
     "semver": {
       "version": "6.3.0",
@@ -8979,9 +9727,9 @@
       }
     },
     "serialize-javascript": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-1.9.1.tgz",
-      "integrity": "sha512-0Vb/54WJ6k5v8sSWN09S0ora+Hnr+cX40r9F170nT+mSkaxltoE/7R3OrIdBSUv1OoiobH1QoWQbCnAO+e8J1A==",
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-2.1.2.tgz",
+      "integrity": "sha512-rs9OggEUF0V4jUSecXazOYsLfu7OGK2qIn3c7IPBiffz32XniEp/TX9Xmc9LQfK2nQ2QKHvZ2oygKUGU0lG4jQ==",
       "dev": true
     },
     "serve-static": {
@@ -9149,12 +9897,6 @@
           "requires": {
             "is-extendable": "^0.1.0"
           }
-        },
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
         }
       }
     },
@@ -9254,16 +9996,6 @@
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
-        },
-        "socket.io-parser": {
-          "version": "3.4.0",
-          "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.4.0.tgz",
-          "integrity": "sha512-/G/VOI+3DBp0+DJKW4KesGnQkQPFmUCbA/oO2QGT6CWxU7hLGWqU3tyuzeSK/dqcyeHsQg1vTe9jiZI8GU9SCQ==",
-          "requires": {
-            "component-emitter": "1.2.1",
-            "debug": "~4.1.0",
-            "isarray": "2.0.1"
-          }
         }
       }
     },
@@ -9301,30 +10033,70 @@
             "ms": "^2.1.1"
           }
         },
+        "isarray": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz",
+          "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4="
+        },
         "ms": {
           "version": "2.1.2",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+        },
+        "socket.io-parser": {
+          "version": "3.3.0",
+          "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.3.0.tgz",
+          "integrity": "sha512-hczmV6bDgdaEbVqhAeVMM/jfUfzuEZHsQg6eOmLgJht6G3mPKMxYm75w2+qhAQZ+4X+1+ATZ+QFKeOZD5riHng==",
+          "requires": {
+            "component-emitter": "1.2.1",
+            "debug": "~3.1.0",
+            "isarray": "2.0.1"
+          },
+          "dependencies": {
+            "debug": {
+              "version": "3.1.0",
+              "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
+              "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
+              "requires": {
+                "ms": "2.0.0"
+              }
+            },
+            "ms": {
+              "version": "2.0.0",
+              "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+              "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+            }
+          }
         }
       }
     },
     "socket.io-parser": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.3.0.tgz",
-      "integrity": "sha512-hczmV6bDgdaEbVqhAeVMM/jfUfzuEZHsQg6eOmLgJht6G3mPKMxYm75w2+qhAQZ+4X+1+ATZ+QFKeOZD5riHng==",
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.4.0.tgz",
+      "integrity": "sha512-/G/VOI+3DBp0+DJKW4KesGnQkQPFmUCbA/oO2QGT6CWxU7hLGWqU3tyuzeSK/dqcyeHsQg1vTe9jiZI8GU9SCQ==",
       "requires": {
         "component-emitter": "1.2.1",
-        "debug": "~3.1.0",
+        "debug": "~4.1.0",
         "isarray": "2.0.1"
       },
       "dependencies": {
         "debug": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-          "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
+          "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
           "requires": {
-            "ms": "2.0.0"
+            "ms": "^2.1.1"
           }
+        },
+        "isarray": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz",
+          "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4="
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
         }
       }
     },
@@ -9335,18 +10107,18 @@
       "dev": true
     },
     "source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "version": "0.5.7",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+      "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
       "dev": true
     },
     "source-map-resolve": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz",
-      "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==",
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz",
+      "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==",
       "dev": true,
       "requires": {
-        "atob": "^2.1.1",
+        "atob": "^2.1.2",
         "decode-uri-component": "^0.2.0",
         "resolve-url": "^0.2.1",
         "source-map-url": "^0.4.0",
@@ -9361,6 +10133,14 @@
       "requires": {
         "buffer-from": "^1.0.0",
         "source-map": "^0.6.0"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "source-map-url": {
@@ -9401,6 +10181,15 @@
       "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==",
       "dev": true
     },
+    "split": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/split/-/split-1.0.0.tgz",
+      "integrity": "sha1-xDlc5oOrzSVLwo/h2rtuXCfc/64=",
+      "dev": true,
+      "requires": {
+        "through": "2"
+      }
+    },
     "split-string": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
@@ -9520,9 +10309,9 @@
       }
     },
     "stream-shift": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz",
-      "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz",
+      "integrity": "sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==",
       "dev": true
     },
     "string-length": {
@@ -9575,20 +10364,19 @@
       }
     },
     "string.prototype.padend": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.0.0.tgz",
-      "integrity": "sha1-86rvfBcZ8XDF6rHDK/eA2W4h8vA=",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.0.tgz",
+      "integrity": "sha512-3aIv8Ffdp8EZj8iLwREGpQaUZiPyrWrpzMBHvkiSW/bK/EGve9np07Vwy7IJ5waydpGXzQZu/F8Oze2/IWkBaA==",
       "dev": true,
       "requires": {
-        "define-properties": "^1.1.2",
-        "es-abstract": "^1.4.3",
-        "function-bind": "^1.0.2"
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.17.0-next.1"
       }
     },
     "string.prototype.trimleft": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.0.tgz",
-      "integrity": "sha512-FJ6b7EgdKxxbDxc79cOlok6Afd++TTs5szo+zJTUyow3ycrRfJVE2pq3vcN53XexvKZu/DJMDfeI/qMiZTrjTw==",
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.1.tgz",
+      "integrity": "sha512-iu2AGd3PuP5Rp7x2kEZCrB2Nf41ehzh+goo8TV7z8/XDBbsvc6HQIlUl9RjkZ4oyrW1XM5UwlGl1oVEaDjg6Ag==",
       "dev": true,
       "requires": {
         "define-properties": "^1.1.3",
@@ -9596,9 +10384,9 @@
       }
     },
     "string.prototype.trimright": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.0.tgz",
-      "integrity": "sha512-fXZTSV55dNBwv16uw+hh5jkghxSnc5oHq+5K/gXgizHwAvMetdAJlHqqoFC1FSDVPYWLkAKl2cxpUT41sV7nSg==",
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.1.tgz",
+      "integrity": "sha512-qFvWL3/+QIgZXVmJBfpHmxLB7xsUXz6HsUmP8+5dRaC3Q7oKUv9Vo6aMCRZC1smrtyECFsIT30PqBJ1gTjAs+g==",
       "dev": true,
       "requires": {
         "define-properties": "^1.1.3",
@@ -9612,6 +10400,14 @@
       "dev": true,
       "requires": {
         "safe-buffer": "~5.1.0"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        }
       }
     },
     "strip-ansi": {
@@ -9655,6 +10451,16 @@
       "integrity": "sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==",
       "dev": true
     },
+    "style-loader": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-1.1.2.tgz",
+      "integrity": "sha512-0Mpq1ZHFDCNq1F+6avNBgv+7q8V+mWRuzehxyJT+aKgzyN/yfKTwjYqaYwBgx+11UpQxL21zNQfzzlz+JcGURw==",
+      "dev": true,
+      "requires": {
+        "loader-utils": "^1.2.3",
+        "schema-utils": "^2.0.1"
+      }
+    },
     "supports-color": {
       "version": "5.5.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
@@ -9707,6 +10513,80 @@
         }
       }
     },
+    "tap-out": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/tap-out/-/tap-out-2.1.0.tgz",
+      "integrity": "sha512-LJE+TBoVbOWhwdz4+FQk40nmbIuxJLqaGvj3WauQw3NYYU5TdjoV3C0x/yq37YAvVyi+oeBXmWnxWSjJ7IEyUw==",
+      "dev": true,
+      "requires": {
+        "re-emitter": "1.1.3",
+        "readable-stream": "2.2.9",
+        "split": "1.0.0",
+        "trim": "0.0.1"
+      },
+      "dependencies": {
+        "process-nextick-args": {
+          "version": "1.0.7",
+          "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz",
+          "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "2.2.9",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.2.9.tgz",
+          "integrity": "sha1-z3jsb0ptHrQ9JkiMrJfwQudLf8g=",
+          "dev": true,
+          "requires": {
+            "buffer-shims": "~1.0.0",
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~1.0.6",
+            "string_decoder": "~1.0.0",
+            "util-deprecate": "~1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        },
+        "string_decoder": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz",
+          "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.1.0"
+          }
+        }
+      }
+    },
+    "tap-summary": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/tap-summary/-/tap-summary-4.0.0.tgz",
+      "integrity": "sha1-kyFIYrpGfFCgnzeOoOXtxd0EQz0=",
+      "dev": true,
+      "requires": {
+        "ansi-escape": "^1.0.1",
+        "commander": "^2.9.0",
+        "figures": "^2.0.0",
+        "pretty-ms": "^3.0.0",
+        "tap-out": "^2.0.0"
+      },
+      "dependencies": {
+        "figures": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
+          "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=",
+          "dev": true,
+          "requires": {
+            "escape-string-regexp": "^1.0.5"
+          }
+        }
+      }
+    },
     "tapable": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz",
@@ -9714,31 +10594,58 @@
       "dev": true
     },
     "terser": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-4.4.0.tgz",
-      "integrity": "sha512-oDG16n2WKm27JO8h4y/w3iqBGAOSCtq7k8dRmrn4Wf9NouL0b2WpMHGChFGZq4nFAQy1FsNJrVQHfurXOSTmOA==",
+      "version": "4.6.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-4.6.1.tgz",
+      "integrity": "sha512-w0f2OWFD7ka3zwetgVAhNMeyzEbj39ht2Tb0qKflw9PmW9Qbo5tjTh01QJLkhO9t9RDDQYvk+WXqpECI2C6i2A==",
       "dev": true,
       "requires": {
         "commander": "^2.20.0",
         "source-map": "~0.6.1",
         "source-map-support": "~0.5.12"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "terser-webpack-plugin": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-1.4.1.tgz",
-      "integrity": "sha512-ZXmmfiwtCLfz8WKZyYUuuHf3dMYEjg8NrjHMb0JqHVHVOSkzp3cW2/XG1fP3tRhqEqSzMwzzRQGtAPbs4Cncxg==",
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-1.4.3.tgz",
+      "integrity": "sha512-QMxecFz/gHQwteWwSo5nTc6UaICqN1bMedC5sMtUc7y3Ha3Q8y6ZO0iCR8pq4RJC8Hjf0FEPEHZqcMB/+DFCrA==",
       "dev": true,
       "requires": {
         "cacache": "^12.0.2",
         "find-cache-dir": "^2.1.0",
         "is-wsl": "^1.1.0",
         "schema-utils": "^1.0.0",
-        "serialize-javascript": "^1.7.0",
+        "serialize-javascript": "^2.1.2",
         "source-map": "^0.6.1",
         "terser": "^4.1.2",
         "webpack-sources": "^1.4.0",
         "worker-farm": "^1.7.0"
+      },
+      "dependencies": {
+        "schema-utils": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz",
+          "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==",
+          "dev": true,
+          "requires": {
+            "ajv": "^6.1.0",
+            "ajv-errors": "^1.0.0",
+            "ajv-keywords": "^3.1.0"
+          }
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "test-exclude": {
@@ -9754,9 +10661,9 @@
       }
     },
     "testcafe": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/testcafe/-/testcafe-1.7.0.tgz",
-      "integrity": "sha512-Y2yZXPCk8Eu/J6yxS5f9H7InJAR1x3LAeZxOY4GOAWiutgzVqFg1BZbWRcIusNaDHTyq0GZJu1XyPd9ueWuuVA==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/testcafe/-/testcafe-1.7.1.tgz",
+      "integrity": "sha512-mLouX1NkfbOsFuXL4gCTpK06qfuoYyVLWc5ZuvRaXT+UyzG39uLL6QqoxZlCA/2e9xHerrGCr9qOLitvxuk08Q==",
       "dev": true,
       "requires": {
         "@types/node": "^10.12.19",
@@ -9821,7 +10728,7 @@
         "source-map-support": "^0.5.16",
         "strip-bom": "^2.0.0",
         "testcafe-browser-tools": "2.0.5",
-        "testcafe-hammerhead": "14.11.1",
+        "testcafe-hammerhead": "15.0.0",
         "testcafe-legacy-api": "3.1.11",
         "testcafe-reporter-json": "^2.1.0",
         "testcafe-reporter-list": "^2.1.0",
@@ -9835,9 +10742,9 @@
       },
       "dependencies": {
         "@types/node": {
-          "version": "10.17.6",
-          "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.6.tgz",
-          "integrity": "sha512-0a2X6cgN3RdPBL2MIlR6Lt0KlM7fOFsutuXcdglcOq6WvLnYXgPQSh0Mx6tO1KCAE8MxbHSOSTWDoUxRq+l3DA==",
+          "version": "10.17.13",
+          "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.13.tgz",
+          "integrity": "sha512-pMCcqU2zT4TjqYFrWtYHKal7Sl30Ims6ulZ4UFXxI4xbtQqK/qqKwkDoBFCfooRqqmRu9vY3xaJRwxSh673aYg==",
           "dev": true
         },
         "chalk": {
@@ -9881,6 +10788,15 @@
             "is-extglob": "^1.0.0"
           }
         },
+        "json5": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.1.tgz",
+          "integrity": "sha512-l+3HXD0GEI3huGq1njuqtzYK8OYJyXMkOLtQ53pjWh89tvWS2h6l+1zMkYWqlb57+SiQodKZyvMEFb2X+KrFhQ==",
+          "dev": true,
+          "requires": {
+            "minimist": "^1.2.0"
+          }
+        },
         "make-dir": {
           "version": "3.0.0",
           "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.0.0.tgz",
@@ -9890,6 +10806,12 @@
             "semver": "^6.0.0"
           }
         },
+        "minimist": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "dev": true
+        },
         "parse5": {
           "version": "1.5.1",
           "resolved": "https://registry.npmjs.org/parse5/-/parse5-1.5.1.tgz",
@@ -10060,9 +10982,9 @@
           }
         },
         "fast-glob": {
-          "version": "3.1.0",
-          "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.1.0.tgz",
-          "integrity": "sha512-TrUz3THiq2Vy3bjfQUB2wNyPdGBeGmdjbzzBLhfHN4YFurYptCKwGq/TfiRavbGywFRzY6U2CdmQ1zmsY5yYaw==",
+          "version": "3.1.1",
+          "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.1.1.tgz",
+          "integrity": "sha512-nTCREpBY8w8r+boyFYAx21iL6faSsQynliPHM4Uf56SbkyohCNxpVPEH9xrF5TXKy+IsjkPUHDKiUkzBVRXn9g==",
           "dev": true,
           "requires": {
             "@nodelib/fs.stat": "^2.0.2",
@@ -10091,9 +11013,9 @@
           }
         },
         "globby": {
-          "version": "10.0.1",
-          "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.1.tgz",
-          "integrity": "sha512-sSs4inE1FB2YQiymcmTv6NWENryABjUNPeWhOvmn4SjtKybglsyPZxFB3U1/+L1bYi0rNZDqCLlHyLYDl1Pq5A==",
+          "version": "10.0.2",
+          "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz",
+          "integrity": "sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==",
           "dev": true,
           "requires": {
             "@types/glob": "^7.1.1",
@@ -10147,15 +11069,15 @@
           }
         },
         "nanoid": {
-          "version": "2.1.7",
-          "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-2.1.7.tgz",
-          "integrity": "sha512-fmS3qwDldm4bE01HCIRqNk+f255CNjnAoeV3Zzzv0KemObHKqYgirVaZA9DtKcjogicWjYcHkJs4D5A8CjnuVQ==",
+          "version": "2.1.9",
+          "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-2.1.9.tgz",
+          "integrity": "sha512-J2X7aUpdmTlkAuSe9WaQ5DsTZZPW1r/zmEWKsGhbADO6Gm9FMd2ZzJ8NhsmP4OtA9oFhXfxNqPlreHEDOGB4sg==",
           "dev": true
         },
         "npm-run-path": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.0.tgz",
-          "integrity": "sha512-8eyAOAH+bYXFPSnNnKr3J+yoybe8O87Is5rtAQ8qRczJz1ajcsjg8l2oZqP+Ppx15Ii3S1vUTjQN2h4YO2tWWQ==",
+          "version": "4.0.1",
+          "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
+          "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
           "dev": true,
           "requires": {
             "path-key": "^3.0.0"
@@ -10245,9 +11167,9 @@
       }
     },
     "testcafe-hammerhead": {
-      "version": "14.11.1",
-      "resolved": "https://registry.npmjs.org/testcafe-hammerhead/-/testcafe-hammerhead-14.11.1.tgz",
-      "integrity": "sha512-huRtP1ttxLe89VZptUNAhPX/Dn/ky8VK0kAijB1Y0MU3EuBpmW7VyAkSRHN/a4Oo845fpgx6w0qx7FTAZZfU3Q==",
+      "version": "15.0.0",
+      "resolved": "https://registry.npmjs.org/testcafe-hammerhead/-/testcafe-hammerhead-15.0.0.tgz",
+      "integrity": "sha512-jgj38U+fERbe/X7D2JOPsej7ywxYza8lCQt5rjCirTx6WawKxxI0GUchRU0SSgQVMzhszt+evtf3Z4cigbZ3gQ==",
       "dev": true,
       "requires": {
         "acorn-hammerhead": "^0.3.0",
@@ -10487,13 +11409,6 @@
         "setimmediate": "^1.0.4"
       }
     },
-    "tiny-worker": {
-      "version": "file:src/tiny-worker",
-      "dev": true,
-      "requires": {
-        "esm": "^3.2.25"
-      }
-    },
     "tmp": {
       "version": "0.0.33",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
@@ -10614,9 +11529,15 @@
       }
     },
     "tree-kill": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.1.tgz",
-      "integrity": "sha512-4hjqbObwlh2dLyW4tcz0Ymw0ggoaVDMveUB9w8kFSQScdRLo0gxO9J7WFcUBo+W3C1TLdFIEwNOWebgZZ0RH9Q==",
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
+      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
+      "dev": true
+    },
+    "trim": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz",
+      "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=",
       "dev": true
     },
     "trim-right": {
@@ -10704,20 +11625,29 @@
       "dev": true
     },
     "typescript": {
-      "version": "3.7.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.2.tgz",
-      "integrity": "sha512-ml7V7JfiN2Xwvcer+XAf2csGO1bPBdRbFCkYBczNZggrBZ9c7G3riSUeJmqEU5uOtXNPMhE3n+R4FA/3YOAWOQ==",
+      "version": "3.7.4",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.4.tgz",
+      "integrity": "sha512-A25xv5XCtarLwXpcDNZzCGvW2D1S3/bACratYBx2sax8PefsFhlYmkQicKHvpYflFS8if4zne5zT5kpJ7pzuvw==",
       "dev": true
     },
     "uglify-js": {
-      "version": "3.7.0",
-      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.7.0.tgz",
-      "integrity": "sha512-PC/ee458NEMITe1OufAjal65i6lB58R1HWMRcxwvdz1UopW0DYqlRL3xdu3IcTvTXsB02CRHykidkTRL+A3hQA==",
+      "version": "3.7.4",
+      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.7.4.tgz",
+      "integrity": "sha512-tinYWE8X1QfCHxS1lBS8yiDekyhSXOO6R66yNOCdUJeojxxw+PX2BHAz/BWyW7PQ7pkiWVxJfIEbiDxyLWvUGg==",
       "dev": true,
       "optional": true,
       "requires": {
         "commander": "~2.20.3",
         "source-map": "~0.6.1"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true,
+          "optional": true
+        }
       }
     },
     "ultron": {
@@ -10738,6 +11668,12 @@
         "set-value": "^2.0.1"
       }
     },
+    "uniq": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz",
+      "integrity": "sha1-sxxa6CVIRKOoKBVBzisEuGWnNP8=",
+      "dev": true
+    },
     "unique-filename": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.1.tgz",
@@ -10798,12 +11734,6 @@
           "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz",
           "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=",
           "dev": true
-        },
-        "isarray": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-          "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
-          "dev": true
         }
       }
     },
@@ -10865,6 +11795,14 @@
       "dev": true,
       "requires": {
         "inherits": "2.0.3"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.3",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+          "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
+          "dev": true
+        }
       }
     },
     "util-deprecate": {
@@ -10973,9 +11911,9 @@
       "dev": true
     },
     "webpack": {
-      "version": "4.41.2",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-4.41.2.tgz",
-      "integrity": "sha512-Zhw69edTGfbz9/8JJoyRQ/pq8FYUoY0diOXqW0T6yhgdhCv6wr0hra5DwwWexNRns2Z2+gsnrNcbe9hbGBgk/A==",
+      "version": "4.41.5",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-4.41.5.tgz",
+      "integrity": "sha512-wp0Co4vpyumnp3KlkmpM5LWuzvZYayDwM2n17EHFr4qxBBbRokC7DJawPJC7TfSFZ9HZ6GsdH40EBj4UV0nmpw==",
       "dev": true,
       "requires": {
         "@webassemblyjs/ast": "1.8.5",
@@ -10998,7 +11936,7 @@
         "node-libs-browser": "^2.2.1",
         "schema-utils": "^1.0.0",
         "tapable": "^1.1.3",
-        "terser-webpack-plugin": "^1.4.1",
+        "terser-webpack-plugin": "^1.4.3",
         "watchpack": "^1.6.0",
         "webpack-sources": "^1.4.1"
       },
@@ -11018,6 +11956,17 @@
             "esrecurse": "^4.1.0",
             "estraverse": "^4.1.1"
           }
+        },
+        "schema-utils": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz",
+          "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==",
+          "dev": true,
+          "requires": {
+            "ajv": "^6.1.0",
+            "ajv-errors": "^1.0.0",
+            "ajv-keywords": "^3.1.0"
+          }
         }
       }
     },
@@ -11058,6 +12007,15 @@
             "escape-string-regexp": "^1.0.5",
             "supports-color": "^5.3.0"
           }
+        },
+        "ws": {
+          "version": "6.2.1",
+          "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.1.tgz",
+          "integrity": "sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==",
+          "dev": true,
+          "requires": {
+            "async-limiter": "~1.0.0"
+          }
         }
       }
     },
@@ -11181,12 +12139,6 @@
         "lodash": "^4.17.15"
       }
     },
-    "webpack-preprocessor-loader": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/webpack-preprocessor-loader/-/webpack-preprocessor-loader-1.1.2.tgz",
-      "integrity": "sha512-YR9UksXYYr0WOEfMTxU0NhKdnfu0BzRvLIxQfkjzyCgyPyeXqv69Nm2JtCykD83cB6Hukr4EtpgztmfMPukpIw==",
-      "dev": true
-    },
     "webpack-sources": {
       "version": "1.4.3",
       "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.4.3.tgz",
@@ -11195,12 +12147,21 @@
       "requires": {
         "source-list-map": "^2.0.0",
         "source-map": "~0.6.1"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
       }
     },
     "webrtc-adapter": {
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/webrtc-adapter/-/webrtc-adapter-7.3.0.tgz",
       "integrity": "sha512-pKcwt6IR6RLCD6jlcdOOi88iVwdzppHlkOhtgTSuZHtYTxdD09t5fA1Di7GJU7je8oHcCBlNfb7zwBsetERnmQ==",
+      "dev": true,
       "requires": {
         "rtcpeerconnection-shim": "^1.2.15",
         "sdp": "^2.10.0"
@@ -11210,6 +12171,7 @@
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/what-the-pack/-/what-the-pack-2.0.3.tgz",
       "integrity": "sha512-vJFrS6U6acWUgkKu9dLuMsQnnHEzIpop1VDMc142h+zU+jUcS+FZlRO/BDJ9/S9cvp2sQWygImBDwl0WN9aadw==",
+      "dev": true,
       "requires": {
         "buffer": "^5.2.1",
         "pretty-bytes": "^5.1.0"
@@ -11293,7 +12255,8 @@
     "wildemitter": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/wildemitter/-/wildemitter-1.2.1.tgz",
-      "integrity": "sha512-UMmSUoIQSir+XbBpTxOTS53uJ8s/lVhADCkEbhfRjUGFDPme/XGOb0sBWLx5sTz7Wx/2+TlAw1eK9O5lw5PiEw=="
+      "integrity": "sha512-UMmSUoIQSir+XbBpTxOTS53uJ8s/lVhADCkEbhfRjUGFDPme/XGOb0sBWLx5sTz7Wx/2+TlAw1eK9O5lw5PiEw==",
+      "dev": true
     },
     "word-wrap": {
       "version": "1.2.3",
@@ -11379,12 +12342,9 @@
       }
     },
     "ws": {
-      "version": "6.1.4",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-6.1.4.tgz",
-      "integrity": "sha512-eqZfL+NE/YQc1/ZynhojeV8q+H050oR8AZ2uIev7RU10svA9ZnJUddHcOUZTJLinZ9yEfdA2kSATS2qZK5fhJA==",
-      "requires": {
-        "async-limiter": "~1.0.0"
-      }
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.2.1.tgz",
+      "integrity": "sha512-sucePNSafamSKoOqoNfBd8V0StlkzJKL2ZAhGQinCfNQ+oacw+Pk7lcdAElecBF2VkLNZRiIb5Oi1Q5lVUVt2A=="
     },
     "xml-name-validator": {
       "version": "3.0.0",
@@ -11406,17 +12366,20 @@
     "y-array": {
       "version": "10.1.4",
       "resolved": "https://registry.npmjs.org/y-array/-/y-array-10.1.4.tgz",
-      "integrity": "sha1-4TGlsDDW3LyhAmjUKT7PRL2uezQ="
+      "integrity": "sha1-4TGlsDDW3LyhAmjUKT7PRL2uezQ=",
+      "dev": true
     },
     "y-map": {
       "version": "10.1.3",
       "resolved": "https://registry.npmjs.org/y-map/-/y-map-10.1.3.tgz",
-      "integrity": "sha1-oVgCztusNp5Qa5b2je+PCi6DYZY="
+      "integrity": "sha1-oVgCztusNp5Qa5b2je+PCi6DYZY=",
+      "dev": true
     },
     "y-memory": {
       "version": "8.0.9",
       "resolved": "https://registry.npmjs.org/y-memory/-/y-memory-8.0.9.tgz",
-      "integrity": "sha512-OrcReh6DgZhz5R7JGXqAH53T0Ygw24qcxKj4jN9w2DIi2eIiKFCD5Y6apBTTNxiw2FaVP15F+M8phRRIMXFGBQ=="
+      "integrity": "sha512-OrcReh6DgZhz5R7JGXqAH53T0Ygw24qcxKj4jN9w2DIi2eIiKFCD5Y6apBTTNxiw2FaVP15F+M8phRRIMXFGBQ==",
+      "dev": true
     },
     "y18n": {
       "version": "4.0.0",
@@ -11424,12 +12387,6 @@
       "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
       "dev": true
     },
-    "yaeti": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/yaeti/-/yaeti-1.0.2.tgz",
-      "integrity": "sha512-sc1JByruVRqL6GYdIKbcvYw8PRmYeuwtSd376fM13DNE+JjBh37qIlKjCtqg9mKV2N2+xCfyil3Hd6BXN9W1uQ==",
-      "dev": true
-    },
     "yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
@@ -11489,6 +12446,15 @@
         "decamelize": "^1.2.0"
       }
     },
+    "yauzl": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.4.1.tgz",
+      "integrity": "sha1-lSj0QtqxsihOWLQ3m7GU4i4MQAU=",
+      "dev": true,
+      "requires": {
+        "fd-slicer": "~1.0.1"
+      }
+    },
     "yeast": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/yeast/-/yeast-0.1.2.tgz",
@@ -11496,9 +12462,16 @@
     },
     "yjs": {
       "version": "file:src/yjs",
+      "dev": true,
       "requires": {
         "debug": "^2.6.3"
       }
+    },
+    "zora": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/zora/-/zora-3.1.8.tgz",
+      "integrity": "sha512-AArEyKiLWi3eLXW2uRbfPvANfSQgV8VHoCuXCihCTQyUv7brFrghGbsUqKxqucc+QodQ1G2+O8Gpsz8RVpeiRQ==",
+      "dev": true
     }
   }
 }

package.json

@@ -13,12 +13,13 @@
     "build": "webpack --config webpack.prod.js",
     "build:analyze": "webpack --env.analyze --config webpack.prod.js",
     "build:dev": "webpack --config webpack.dev.js",
+    "build:bench": "webpack --config webpack.bench.js",
     "watch": "webpack --watch --config webpack.dev.js",
     "start": "node --experimental-modules src/server.js",
-    "test": "jest --testPathIgnorePatterns .*.data.js .*benchmark.test.js src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/tiny-worker",
-    "test-changed": "jest --only-changed --testPathIgnorePatterns __tests__/*.data.js src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/tiny-worker",
-    "test-coverage": "jest --coverage --testPathIgnorePatterns __tests__/*.data.js src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/tiny-worker",
-    "test-benchmark": "jest --testPathPattern .*benchmark.test.js --testPathIgnorePatterns .*.data.js src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/tiny-worker",
+    "test": "jest --testPathIgnorePatterns src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/drawing-crdt",
+    "test-changed": "jest --only-changed --testPathIgnorePatterns src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/drawing-crdt",
+    "test-coverage": "jest --coverage --testPathIgnorePatterns src/liowebrtc src/rtcpeerconnection src/signalbuddy src/yjs src/drawing-crdt",
+    "benchmarks": "node --experimental-modules __benchmarks__/puppeteer.js | npx tap-summary --no-progress",
     "test-e2e:peer1": "testcafe chrome:headless __e2e_tests__/peer1.e2e.js",
     "test-e2e:peer2": "testcafe chrome:headless __e2e_tests__/peer2.e2e.js",
     "test-e2e": "run-p test-e2e:*",
@@ -27,44 +28,54 @@
     "format": "prettier --ignore-path .gitignore --check --write '**/*.{html,js,json,md}'",
     "format-check": "prettier --ignore-path .gitignore --check '**/*.{html,js,json,md}'",
     "lint": "eslint --ignore-path .gitignore '**/*.js'",
-    "validate": "npm ls"
+    "validate": "npm ls",
+    "plot": "find plot-scripts/ -maxdepth 1 -type f -name '*.p' -exec gnuplot {} \\;"
   },
   "dependencies": {
-    "@ungap/event-target": "^0.1.0",
-    "d3-shape": "^1.3.5",
+    "@xmpp/client": "^0.9.2",
     "dotenv": "^8.2.0",
     "express": "^4.17.1",
-    "humanhash": "^1.0.4",
-    "jdenticon": "^2.2.0",
-    "liowebrtc": "file:src/liowebrtc",
-    "pako": "^1.0.10",
-    "rtcpeerconnection": "file:src/rtcpeerconnection",
     "signalbuddy": "file:src/signalbuddy",
-    "uuid": "^3.3.3",
-    "webrtc-adapter": "^7.3.0",
-    "what-the-pack": "^2.0.3",
-    "y-array": "^10.1.4",
-    "y-map": "^10.1.3",
-    "y-memory": "^8.0.9",
-    "yjs": "file:src/yjs"
+    "uuid": "^3.3.3"
   },
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.6.0",
+    "@fortawesome/fontawesome-free": "^5.12.0",
+    "@ungap/event-target": "^0.1.0",
+    "array-flat-polyfill": "^1.0.1",
+    "babel-eslint": "^10.0.3",
     "chalk": "^3.0.0",
+    "css-loader": "^3.4.1",
+    "d3-shape": "^1.3.5",
+    "drawing-crdt": "file:src/drawing-crdt/pkg",
     "eslint": "^6.5.1",
     "eslint-config-prettier": "^6.5.0",
     "eslint-plugin-testcafe": "^0.2.1",
+    "fastbitset": "^0.2.8",
+    "file-loader": "^5.0.2",
+    "humanhash": "^1.0.4",
+    "jdenticon": "^2.2.0",
     "jest": "^24.9.0",
+    "liowebrtc": "file:src/liowebrtc",
     "npm-run-all": "^4.1.5",
+    "pako": "^1.0.10",
     "prettier": "^1.18.2",
+    "puppeteer-core": "^2.0.0",
+    "rtcpeerconnection": "file:src/rtcpeerconnection",
+    "style-loader": "^1.1.2",
+    "tap-summary": "^4.0.0",
     "testcafe": "^1.5.0",
-    "tiny-worker": "file:src/tiny-worker",
     "webpack": "^4.41.0",
     "webpack-bundle-analyzer": "^3.6.0",
     "webpack-cli": "^3.3.9",
     "webpack-merge": "^4.2.2",
-    "webpack-preprocessor-loader": "^1.1.2",
-    "yaeti": "^1.0.2"
+    "webrtc-adapter": "^7.3.0",
+    "what-the-pack": "^2.0.3",
+    "y-array": "^10.1.4",
+    "y-map": "^10.1.3",
+    "y-memory": "^8.0.9",
+    "yjs": "file:src/yjs",
+    "zora": "^3.1.8"
   },
   "pre-commit": [
     "lint",

plot-scripts/demo.p

+set xlabel "Iterations"
+set ylabel "Time [ms]"
+set title "addPath() performance scalability"
+set key inside bottom right
+
+set terminal dumb size 120, 30
+set autoscale
+
+plot "plots/dot-seq-benchmark.tsv" using 1:($2/(1e6*$1)) with lines title "dot [sequential]"
+
+set terminal pdf
+set output "plots/dot-seq-benchmark.pdf"
+
+plot "plots/dot-seq-benchmark.tsv" using 1:($2/(1e6*$1)) with lines title "dot [sequential]"

public/imperial.svg

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 22.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 417.7 150.7" style="enable-background:new 0 0 417.7 150.7;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#003C70;}
+</style>
+<path class="st0" d="M28.4,68.2V30.3h7.4v37.9H28.4z"/>
+<path class="st0" d="M46.7,44.3h0.1c1.8-2.4,5.2-3.8,8.3-3.8c3.3,0,6.2,1.4,7.8,3.8c2.2-2.2,5.6-3.8,8.8-3.8c6-0.1,9.1,3.7,9.2,9.9
+	v17.8h-7V51.7c0-3.1-1.1-6.4-4.5-6.4c-3.4,0-5.5,2.1-5.5,6.8v16.2h-7V51.7c0-3.8-1.6-6.4-4.6-6.4c-3.3,0-5.4,2.3-5.4,6.9v16h-7V41.1
+	h7V44.3z"/>
+<path class="st0" d="M98.5,44.8c4,0,6,4.7,6,9.3c0,4.8-1.6,10.4-6.3,10.4c-3.8,0-6.5-3.8-6.5-9.5C91.8,48.7,94.1,44.8,98.5,44.8z
+	 M91.8,41.1h-7v40.7h7V64.8c2,2.4,4.7,4,7.9,4c7.5,0,12.3-7.6,12.3-14.8c0-6-3.4-13.6-11.7-13.6c-3.2,0-6.6,1.6-8.4,4.4h-0.1V41.1z"
+	/>
+<path class="st0" d="M122,51.4c-0.1-3.6,1.7-6.9,5.8-6.9c3.5,0,4.9,2.8,4.6,6.9H122z M139,55.3c0.5-8.1-2.9-14.8-11.1-14.8
+	c-7.5,0-13.5,5.3-13.5,13.7c0,8.9,6,14.7,13.9,14.7c3,0,6.8-0.9,10.3-3l-2-3.8c-1.7,1.2-4.5,2.2-7.1,2.2c-4.4,0-7.9-3.8-7.7-8.9H139
+	z"/>
+<path class="st0" d="M149.4,45.9h0.1l1.4-2.1c0.8-1.1,2.4-3.3,4.5-3.3c1.6,0,3.3,0.9,4.8,2.4l-2.6,5c-1.2-0.6-1.9-0.9-3.3-0.9
+	c-2.4,0-4.8,2-4.8,7.9v13.4h-7V41.1h7V45.9z"/>
+<path class="st0" d="M169.4,41.1v27.1h-7V41.1H169.4z M161.7,33c0-2.1,1.7-4.2,4.1-4.2c2.4,0,4.3,2.1,4.3,4.2c0,2.3-1.6,4.5-4.2,4.5
+	C163.4,37.5,161.7,35.3,161.7,33z"/>
+<path class="st0" d="M188.5,52.5c0.5,8-3.1,11.5-5.9,11.5c-1.7,0-3.2-1.6-3.2-4c0-3.1,1.7-5.1,5.2-6.2L188.5,52.5z M188.4,64.2
+	c0,1.5,0.2,3,0.7,4h7.4c-0.8-1.9-1.1-4.4-1.1-6.6V50.5c0-8.5-6-10.1-10.8-10.1c-3.6,0-6.9,0.9-10.1,3.7l2.3,3.4c1.8-1.6,4-2.8,7-2.8
+	c2.3,0,4.4,1.6,4.8,4.1l-6.2,1.9c-6.1,1.8-9.8,4.7-9.8,9.9c0,5,3.4,8.2,7.5,8.2c2.4,0,4.8-1.7,6.8-3.3L188.4,64.2z"/>
+<path class="st0" d="M199.8,68.2V28.4h7v39.8H199.8z"/>
+<path class="st0" d="M253.1,37.1c-1.8-1-4.8-2.1-7.7-2.1c-7.6,0-13.1,5.5-13.1,14.1c0,9,6.1,14.3,13.3,14.3c2.9,0,5.5-0.8,7.4-1.9
+	l2.1,4.7c-2.3,1.4-6.2,2.6-9.8,2.6c-12.8,0-20.9-8.7-20.9-19.8c0-10.4,8-19.4,21-19.4c3.9,0,7.4,1.4,10,2.9L253.1,37.1z"/>
+<path class="st0" d="M269.1,64.8c-5,0-6.4-5.7-6.4-10.5c0-4.5,1.6-9.9,6.4-9.9c4.9,0,6.4,5.4,6.4,9.9
+	C275.5,59.1,274.2,64.8,269.1,64.8z M269.1,68.9c8.3,0,13.9-6.1,13.9-14.5c0-8.8-6.7-13.9-13.9-13.9c-7.1,0-13.8,5.1-13.8,13.9
+	C255.3,62.7,260.8,68.9,269.1,68.9z"/>
+<path class="st0" d="M286,68.2V28.4h7v39.8H286z"/>
+<path class="st0" d="M297.4,68.2V28.4h7v39.8H297.4z"/>
+<path class="st0" d="M314.9,51.4c-0.1-3.6,1.7-6.9,5.7-6.9c3.5,0,4.9,2.8,4.6,6.9H314.9z M331.9,55.3c0.5-8.1-2.9-14.8-11.1-14.8
+	c-7.5,0-13.5,5.3-13.5,13.7c0,8.9,6,14.7,13.9,14.7c3,0,6.8-0.9,10.3-3l-2-3.8c-1.7,1.2-4.5,2.2-7.1,2.2c-4.4,0-7.9-3.8-7.7-8.9
+	H331.9z"/>
+<path class="st0" d="M372.2,51.4c-0.1-3.6,1.7-6.9,5.8-6.9c3.5,0,4.9,2.8,4.6,6.9H372.2z M389.2,55.3c0.5-8.1-2.9-14.8-11.1-14.8
+	c-7.5,0-13.5,5.3-13.5,13.7c0,8.9,6,14.7,13.9,14.7c3,0,6.8-0.9,10.3-3l-2-3.8c-1.7,1.2-4.5,2.2-7.1,2.2c-4.4,0-7.9-3.8-7.7-8.9
+	H389.2z"/>
+<path class="st0" d="M348.3,44.8c4.2,0,6.4,4.4,6.4,9.1c0,5.4-2,10.6-6.7,10.6c-4.1,0-6.1-5.1-6.1-10.4
+	C342,48.9,343.8,44.8,348.3,44.8z M361.7,41.1h-7v3.3h-0.1c-1.5-2.4-4.6-4-7.9-4c-7.2,0-12.2,6.8-12.2,13.9
+	c0,8.7,4.6,14.5,11.6,14.5c4,0,6.8-2.3,8.5-4.6h0.1v3.6c0,6.3-3.6,9.2-8.2,9.2c-3.6,0-6.6-0.7-9.2-2.3l-1.4,4.4
+	c3.1,1.6,7.1,2.6,11.1,2.6c7.9,0,14.7-4,14.7-16V41.1z"/>
+<path class="st0" d="M28.4,84.5h7.5v32.8h15.8v5.1H28.4V84.5z"/>
+<path class="st0" d="M92.8,98.5c2.5-2.6,6-3.8,9.5-3.8c6.5,0,9.6,3.5,9.6,10.3v17.5h-7.1v-16.6c0-3.8-1.7-6.3-5.6-6.3
+	c-3.6,0-6.4,2.3-6.4,6.8v16.2h-7.1V95.3h7V98.5z"/>
+<path class="st0" d="M130.2,99c4.4,0,6.7,4.4,6.7,9.1c0,5.4-2.1,10.6-7.1,10.6c-4.3,0-6.4-5.1-6.4-10.4S125.4,99,130.2,99z
+	 M136.9,122.4h7.1V82.6h-7.1v15.9h-0.1c-1.7-2.4-4.9-3.8-8.5-3.8c-7.4,0-12.7,6.8-12.7,13.9c0,8.7,4.8,14.5,12.1,14.5
+	c4.3,0,7.2-2.3,9-4.6h0.1V122.4z"/>
+<path class="st0" d="M162.3,119c-5.3,0-6.7-5.7-6.7-10.5c0-4.5,1.7-9.9,6.7-9.9c5.2,0,6.8,5.4,6.8,9.9
+	C169,113.3,167.6,119,162.3,119z M162.3,123.1c8.7,0,14.6-6.1,14.6-14.5c0-8.8-7.1-13.9-14.6-13.9c-7.4,0-14.5,5.1-14.5,13.9
+	C147.7,116.9,153.6,123.1,162.3,123.1z"/>
+<path class="st0" d="M187.7,98.5c2.5-2.6,6-3.8,9.5-3.8c6.5,0,9.6,3.5,9.6,10.3v17.5h-7.1v-16.6c0-3.8-1.7-6.3-5.6-6.3
+	c-3.6,0-6.4,2.3-6.4,6.8v16.2h-7.1V95.3h7V98.5z"/>
+<path class="st0" d="M67.2,119c-5.3,0-6.7-5.7-6.7-10.5c0-4.5,1.7-9.9,6.7-9.9c5.2,0,6.8,5.4,6.8,9.9C74,113.3,72.6,119,67.2,119z
+	 M67.2,123.1c8.7,0,14.6-6.1,14.6-14.5c0-8.8-7.1-13.9-14.6-13.9c-7.4,0-14.5,5.1-14.5,13.9C52.7,116.9,58.6,123.1,67.2,123.1z"/>
+</svg>

public/index.html

@@ -6,11 +6,6 @@
     <link rel="shortcut icon" href="logo.png" />
     <link rel="apple-touch-icon" href="logo.png" />
     <link rel="stylesheet" href="styles.css" />
-
-    <link
-      rel="stylesheet"
-      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
-    />
     <script>
       if (navigator.serviceWorker) {
         navigator.serviceWorker.register("service-worker.js").then(
@@ -25,17 +20,10 @@
     </script>
   </head>
   <body>
-    <div style="display:none">
-      Your client ID: <input id="user-id" type="text" value="" readonly="" />
-    </div>
-    <div style="display:none">
-      Enter peer ID: <input id="peer-id" type="text" value="" />
-      <button id="peer-connect">Connect</button>
-    </div>
     <div id="top-panel">
       <div class="top-bar">
         <div class="dropdown">
-          <button class="dropdown-peers"><i class="fa fa-bars"></i></button>
+          <button class="dropdown-peers"><i class="fas fa-bars"></i></button>
           <div class="peers">
             <ul id="connected-peers">
               No peers are connected
@@ -57,11 +45,11 @@
           size="25"
           color="gray"
         />
-        <button id="room-connect">Connect <i class="fa fa-link"></i></button>
+        <button id="room-connect">Connect <i class="fas fa-link"></i></button>
       </div>
       <div id="tools-panel">
-        <button id="pen-tool" class="selected">
-          <i class="fa fa-paint-brush"></i>
+        <button id="pen-tool" class="selectable-tool selected">
+          <i class="fas fa-paint-brush"></i>
         </button>
         <div id="pen-properties" class="properties">
           <div class="pen-contents">
@@ -86,8 +74,7 @@
                 <input
                   type="range"
                   min="1"
-                  max="100"
-                  value="10"
+                  max="10"
                   class="slider"
                   id="range"
                 />
@@ -192,23 +179,51 @@
                 <b>Other colours</b>
               </div>
               <label id="colours">
-                <input id="other-colours" type="color" value="#0000ff" />
+                <input id="other-colours" type="color" />
               </label>
             </div>
           </div>
         </div>
-        <button id="eraser-tool"><i class="fa fa-eraser"></i></button>
+        <button id="eraser-tool" class="selectable-tool">
+          <i class="fas fa-eraser"></i>
+        </button>
+        <button id="dragging-tool" class="selectable-tool">
+          <i class="far fa-hand-paper"></i>
+        </button>
+        <button id="canvas-center" class="selectable-tool">
+          <i class="fas fa-crosshairs"></i>
+        </button>
+        <button id="recognition-mode" class="selectable-tool">
+          <i class="fas fa-square"></i>
+        </button>
+        <div class="spacer"></div>
+
         <div id="status-info">
-          <div id="user-avatar"></div>
+          <button id="fast-undo-tool" class="disabled selectable-tool">
+            <i class="fas fa-fast-backward"></i>
+          </button>
+          <button id="undo-tool" class="disabled selectable-tool">
+            <i class="fas fa-step-backward"></i>
+          </button>
           <div id="connected-room-info">
-            Room <i class="fa fa-globe">: </i> &nbsp;
+            Room:&nbsp;
             <span id="connected-room-id"></span>
           </div>
+          <div id="user-avatar"></div>
+          <div id="imperial-logo">
+            <img
+              src="imperial.svg"
+              alt="Imperial College London Logo"
+              height="42px"
+            />
+          </div>
         </div>
       </div>
     </div>
 
-    <svg id="canvas"></svg>
+    <div id="canvas-container">
+      <svg id="canvas"></svg>
+    </div>
 
     <script src="js/app.js"></script>
   </body>

public/styles.css

@@ -14,11 +14,21 @@ body {
   flex-direction: column;
 }
 
-#canvas {
+#canvas-container {
   width: calc(100vw - 8px);
   background-color: white;
   border: 4px solid red;
   flex-grow: 1;
+  position: relative;
+  overflow: hidden;
+}
+
+#canvas {
+  position: absolute;
+  left: -5000px;
+  top: -5000px;
+  width: 10000px;
+  height: 10000px;
 }
 
 #tools-panel {
@@ -27,20 +37,18 @@ body {
   align-items: center;
 }
 
+.spacer {
+  flex: 1;
+}
+
 #connected-room-info {
   color: white;
   display: flex;
   align-items: center;
   background-color: #4f4f4fb7;
   border-radius: 4px;
-  margin-left: 8px;
   justify-content: center;
-  height: 44px;
-}
-
-#connected-room-info:hover {
-  background-color: #4f4f4f !important;
-  transition-duration: 0.4s;
+  padding: 0.75em;
 }
 
 button.selected {
@@ -73,7 +81,7 @@ button.selected {
   cursor: pointer;
   border-radius: 4px;
   transition-duration: 0.4s;
-  height: 100%;
+  height: 36px;
   width: 36px;
 }
 
@@ -267,9 +275,13 @@ button.selected {
   border: none;
   cursor: pointer;
   border-radius: 4px;
+  width: 78px;
+  height: 36px;
+  white-space: nowrap;
+  overflow: hidden;
 }
 
-#pen-tool {
+.selectable-tool {
   background-color: #2f2f2f;
   color: white;
   padding: 10px;
@@ -277,27 +289,89 @@ button.selected {
   border: none;
   cursor: pointer;
   border-radius: 50%;
-  margin-right: 8px;
 }
 
-#pen-tool:hover {
+.selectable-tool:hover {
   background-color: #4f4f4f !important;
   transition-duration: 0.4s;
 }
 
+#pen-tool {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#pen-tool > i {
+  padding: 0 1.5px;
+}
+
 #eraser-tool {
-  background-color: #2f2f2f;
-  color: white;
-  padding: 10px;
-  font-size: 16px;
-  border: none;
-  cursor: pointer;
-  border-radius: 50%;
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
 }
 
-#eraser-tool:hover {
-  background-color: #4f4f4f !important;
-  transition-duration: 0.4s;
+#eraser-tool > i {
+  padding: 0 1.5px;
+}
+
+#dragging-tool {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#dragging-tool > i {
+  padding: 0 2.5px;
+}
+
+#canvas-center {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#canvas-center > i {
+  padding: 0 1.5px;
+}
+
+#recognition-mode {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#recognition-mode > i {
+  padding: 0 2.5px;
+}
+
+#undo-tool {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#undo-tool.disabled {
+  display: none;
+}
+
+#undo-tool > i {
+  padding: 0 2.5px;
+}
+
+#fast-undo-tool {
+  width: 39px;
+  height: 39px;
+  margin-right: 8px;
+}
+
+#fast-undo-tool.disabled {
+  display: none;
+}
+
+#fast-undo-tool > i {
+  padding: 0 1.5px;
 }
 
 .properties {
@@ -547,16 +621,21 @@ button.selected {
   align-items: center;
   background-color: #4f4f4fb7;
   border-radius: 4px;
-}
-
-#user-avatar:hover {
-  background-color: #4f4f4f !important;
-  transition-duration: 0.4s;
+  margin-left: 0.75em;
+  padding: 0 0.75em 0 0;
 }
 
 #status-info {
   display: flex;
   align-items: center;
   justify-content: right;
-  width: 100%;
+}
+
+#imperial-logo {
+    background-color: white;
+    display: flex;
+    align-items: center;
+    border-radius: 4px;
+    margin-left: 0.75em;
+    padding: 0;
 }