segundo commit

2025-11-06 19:19:45 +00:00 · 2025-11-06 19:19:45 +00:00 · d2e79d63a5
commit d2e79d63a5
parent 6b8b75863a
13601 changed files with 1117197 additions and 0 deletions
--- a/ARTIVISMO_THS/1984.jpg
+++ b/ARTIVISMO_THS/1984.jpg
--- a/ARTIVISMO_THS/agua.jpg
+++ b/ARTIVISMO_THS/agua.jpg
--- a/ARTIVISMO_THS/armas_banksy.jpg
+++ b/ARTIVISMO_THS/armas_banksy.jpg
--- a/ARTIVISMO_THS/calculators.jpg
+++ b/ARTIVISMO_THS/calculators.jpg
--- a/ARTIVISMO_THS/cambiar_las_cosas.jpg
+++ b/ARTIVISMO_THS/cambiar_las_cosas.jpg
--- a/ARTIVISMO_THS/chess_kings.jpg
+++ b/ARTIVISMO_THS/chess_kings.jpg
--- a/ARTIVISMO_THS/crean_desiertos.jpg
+++ b/ARTIVISMO_THS/crean_desiertos.jpg
--- a/ARTIVISMO_THS/cyberpunk.jpg
+++ b/ARTIVISMO_THS/cyberpunk.jpg
--- a/ARTIVISMO_THS/declarar_desolacion.jpg
+++ b/ARTIVISMO_THS/declarar_desolacion.jpg
--- a/ARTIVISMO_THS/desgazado.jpeg
+++ b/ARTIVISMO_THS/desgazado.jpeg
--- a/ARTIVISMO_THS/el_pez.jpg
+++ b/ARTIVISMO_THS/el_pez.jpg
--- a/ARTIVISMO_THS/empresnder.jpg
+++ b/ARTIVISMO_THS/empresnder.jpg
--- a/ARTIVISMO_THS/empujar_locomotora.jpg
+++ b/ARTIVISMO_THS/empujar_locomotora.jpg
--- a/ARTIVISMO_THS/gato.jpg
+++ b/ARTIVISMO_THS/gato.jpg
--- a/ARTIVISMO_THS/gentrificado.jpg
+++ b/ARTIVISMO_THS/gentrificado.jpg
--- a/ARTIVISMO_THS/index.html.tmp
+++ b/ARTIVISMO_THS/index.html.tmp
--- a/ARTIVISMO_THS/leopardo.jpg
+++ b/ARTIVISMO_THS/leopardo.jpg
--- a/ARTIVISMO_THS/musk.jpg
+++ b/ARTIVISMO_THS/musk.jpg
--- a/ARTIVISMO_THS/musk_1939.jpg
+++ b/ARTIVISMO_THS/musk_1939.jpg
--- a/ARTIVISMO_THS/nueva_brida.jpg
+++ b/ARTIVISMO_THS/nueva_brida.jpg
--- a/ARTIVISMO_THS/politicos_arca.jpg
+++ b/ARTIVISMO_THS/politicos_arca.jpg
--- a/ARTIVISMO_THS/stickers.jpg
+++ b/ARTIVISMO_THS/stickers.jpg
--- a/ARTIVISMO_THS/stop_wars.jpg
+++ b/ARTIVISMO_THS/stop_wars.jpg
--- a/build_gallery.sh
+++ b/build_gallery.sh
@ -0,0 +1,47 @@
 #!/usr/bin/env bash
 set -euo pipefail
 # Carpeta de imágenes y archivo HTML a actualizar
 IMG_DIR="ARTIVISMO_THS"
 HTML="index.html"
 # Extensiones soportadas (añade/quita lo que quieras)
 shopt -s nullglob nocaseglob
 IMGS=("$IMG_DIR"/*.{jpg,jpeg,png,webp,gif})
 # Construye el HTML de la galería en un buffer
 TMP="$(mktemp)"
 {
  echo '<!-- GALLERY:START (no tocar, se rellena automáticamente) -->'
  echo '<section id="galeria" class="galeria" aria-label="Galería de imágenes">'
  for f in "${IMGS[@]}"; do
    base="${f##*/}"                 # nombre con extensión
    title="${base%.*}"              # sin extensión
    title="${title//_/ }"
    title="${title//-/ }"
    # mayúscula inicial simple
    title="$(echo "$title" | awk '{for(i=1;i<=NF;i++){ $i=toupper(substr($i,1,1)) substr($i,2) } ; print }')"
    cat <<EOF
  <figure class="item">
    <img src="$IMG_DIR/$base" alt="$title" loading="lazy">
    <figcaption>
      <h3 class="title">$title</h3>
    </figcaption>
  </figure>
 EOF
  done
  echo '</section>'
  echo '<!-- GALLERY:END -->'
 } > "$TMP"
 # Reemplaza el bloque entre marcadores en index.html
 awk -v RS= -v ORS="" -v repl="$(sed 's/[&/\]/\\&/g' "$TMP")" '
  {
    gsub(/<!-- GALLERY:START[\s\S]*?GALLERY:END -->/, repl);
    print
  }
 ' "$HTML" > "$HTML.tmp" && mv "$HTML.tmp" "$HTML"
 rm -f "$TMP"
 echo "Galería actualizada con ${#IMGS[@]} imágenes en $HTML"
--- a/index.html
+++ b/index.html
@ -0,0 +1,265 @@
 <!doctype html>
 <html lang="es">
 <head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>artivismo</title>
  <!-- Tipos  ^`^|graffiti/artist ^`^} -->
  <link href="https://fonts.googleapis.com/css2?family=Permanent+Marker&family=Rock+Salt&family=Montserrat:wght@400;600;800&display=swap" rel="stylesheet">
  <link rel="stylesheet" href="styles.css" />
  <meta name="color-scheme" content="light">
 </head>
 <body>
  <header class="site-header">
    <div class="brand">
      <h1 class="logo" aria-label="ARTIVISMO">artivismo</h1>
    </div>
    <nav class="nav">
      <a href="#galeria" class="nav-link">Galery</a>
      <a href="#sobre" class="nav-link">About</a>
      <a href="#contacto" class="nav-link">Contact</a>
    </nav>
  </header>
  <main>
    <!-- Controles de categorías (CSS-only) -->
    <section id="filtros" class="filtros" aria-label="Filtrar por categoría">
      <!-- Radios ocultos -->
      <input type="radio" name="cat" id="cat-todo" checked>
      <input type="radio" name="cat" id="cat-mural" checked>
      <input type="radio" name="cat" id="cat-protesta" checked>
      <input type="radio" name="cat" id="cat-collage" checked>
      <input type="radio" name="cat" id="cat-stencil" checked>
      <!-- Etiquetas visibles -->
      <div class="tabs">
        <label class="tab" for="cat-todo">Todo</label>
        <label class="tab" for="cat-mural">Murales</label>
        <label class="tab" for="cat-protesta">Protesta</label>
        <label class="tab" for="cat-collage">Collage</label>
        <label class="tab" for="cat-stencil">Stencil</label>
      </div>
    </section>
    <!-- Galería -->
    <section id="galeria" class="galeria" aria-label="Galería de imágenes">
      <!-- Todos los ítems usan la clase existente "item mural" para no romper el CSS/filters -->
      <figure class="item mural">
        <img src="ARTIVISMO_THS/1984.jpg" alt="1984" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">sten</span>
          <h3 class="title">1984</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/agua.jpg" alt="Agua" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Water</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/armas_banksy.jpg" alt="Dick Launch" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">sten</span>
          <h3 class="title">Dick launch</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/cambiar_las_cosas.jpg" alt="Cambiar las cosas" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Change Things</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/chess_kings.jpg" alt="Chess Kings" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Chess Kings</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/crean_desiertos.jpg" alt="Crean desiertos" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">OASIFICAR</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/cyberpunk.jpg" alt="Cyberpunk" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">flyer</span>
          <h3 class="title">Cyberpunk</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/declarar_desolacion.jpg" alt="Declarar desolación" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Declarar</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/desgazado.jpeg" alt="Desgazado" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">flyer</span>
          <h3 class="title">Desgazado</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/el_pez.jpg" alt="El pez" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">El pez</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/empresnder.jpg" alt="Empresnder" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Entrepeneurship</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/empujar_locomotora.jpg" alt="Empujar locomotora" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Train push</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/gato.jpg" alt="Gato" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">graffiti</span>
          <h3 class="title">CAT</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/gentrificado.jpg" alt="Gentrificado" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">flyer</span>
          <h3 class="title">Gentrificado</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/leopardo.jpg" alt="Leopardo" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Leopard</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/musk.jpg" alt="Musk" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">flyer</span>
          <h3 class="title">Musk</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/musk_1939.jpg" alt="Musk 1939" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">flyer</span>
          <h3 class="title">Musk 1939</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/nueva_brida.jpg" alt="Nueva brida" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">New year</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/politicos_arca.jpg" alt="Políticos Arca" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">draw</span>
          <h3 class="title">Fuck Noe</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/stickers.jpg" alt="Stickers" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">stick</span>
          <h3 class="title">Stickers</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
      <figure class="item mural">
        <img src="ARTIVISMO_THS/stop_wars.jpg" alt="Stop wars" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">sten</span>
          <h3 class="title">Stop wars</h3>
          <p class="meta"></p>
        </figcaption>
      </figure>
    </section>
    <!-- Sobre -->
    <section id="sobre" class="sobre">
      <h2>About</h2>
      <p>
              ARTIVISMO is a space to archive and celebrate images with intention:
              murals, visual protests, collages, stencils and performances. We curate
              pieces that question, move and activate.
      </p>
    </section>
    <!-- Contacto -->
    <section id="contacto" class="contacto">
      <h2>Contact</h2>
      <p>¿Share with us!</p>
      <a class="cta" href="mailto:hola@artivismo.example">artivismo@riseup.net</a>
    </section>
  </main>
  <footer class="site-footer">
    <p><span id="year"></span> ARTIVISMO made with love</p>
  </footer>
  <!-- Año -->
  <script>
    document.getElementById('year').textContent = new Date().getFullYear();
  </script>
 </body>
 </html>
--- a/index.html.tmp
+++ b/index.html.tmp
@ -0,0 +1,135 @@
 <!doctype html>
 <html lang="es">
 <head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>artivismo</title>  <!-- Tipos “graffiti/artist” -->
  <link href="https://fonts.googleapis.com/css2?family=Permanent+Marker&family=Rock+Salt&family=Montserrat:wght@400;600;800&display=swap" rel="stylesheet">
  <link rel="stylesheet" href="styles.css" />
  <meta name="color-scheme" content="light">
 </head>
 <body>
  <header class="site-header">
    <div class="brand">
      <h1 class="logo" aria-label="ARTIVISMO">artivismo</h1>
    </div>
    <nav class="nav">
      <a href="#galeria" class="nav-link">Galería</a>
      <a href="#sobre" class="nav-link">Sobre</a>
      <a href="#contacto" class="nav-link">Contacto</a>
    </nav>
  </header>  <main>
    <!-- Controles de categorías (CSS-only) -->
    <section id="filtros" class="filtros" aria-label="Filtrar por categoría">
      <!-- Radios ocultos -->
      <input type="radio" name="cat" id="cat-todo" checked>
      <input type="radio" name="cat" id="cat-mural" checked>
      <input type="radio" name="cat" id="cat-protesta" checked>
      <input type="radio" name="cat" id="cat-collage" checked>
      <input type="radio" name="cat" id="cat-stencil" checked>
      <input type="radio" name="cat" id="cat-performance" checked>      <!-- Etiquetas visibles -->
      <div class="tabs">
        <label class="tab" for="cat-todo">Todo</label>
        <label class="tab" for="cat-mural">Murales</label>
        <label class="tab" for="cat-protesta">Protesta</label>
        <label class="tab" for="cat-collage">Collage</label>
        <label class="tab" for="cat-stencil">Stencil</label>
        <label class="tab" for="cat-performance">Performance</label>
      </div>
    </section>    <!-- Galería -->
    <section id="galeria" class="galeria" aria-label="Galería de imágenes">
      <!-- ITEM -->
      <figure class="item mural">
        <img src="assets/mural_01.jpg" alt="Mural urbano con colores vivos" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">Mural</span>
          <h3 class="title">“Muros que hablan”</h3>
          <p class="meta">Madrid · 2023</p>
        </figcaption>
      </figure>      <figure class="item protesta">
        <img src="assets/protesta_01.jpg" alt="Carteles de protesta tipografía handmade" loading="lazy">
        <figcaption>
          <span class="chip chip-protesta">Protesta</span>
          <h3 class="title">“Voces en la calle”</h3>
          <p class="meta">Buenos Aires · 2022</p>
        </figcaption>
      </figure>      <figure class="item collage">
        <img src="assets/collage_01.jpg" alt="Collage político en papel y tinta" loading="lazy">
        <figcaption>
          <span class="chip chip-collage">Collage</span>
          <h3 class="title">“Recortes del presente”</h3>
          <p class="meta">Barcelona · 2024</p>
        </figcaption>
      </figure>      <figure class="item stencil">
        <img src="assets/stencil_01.jpg" alt="Stencil de rostro icónico en pared blanca" loading="lazy">
        <figcaption>
          <span class="chip chip-stencil">Stencil</span>
          <h3 class="title">“Sombras y bordes”</h3>
          <p class="meta">Valparaíso · 2021</p>
        </figcaption>
      </figure>      <figure class="item performance">
        <img src="assets/performance_01.jpg" alt="Performance callejera con pancartas fluorescentes" loading="lazy">
        <figcaption>
          <span class="chip chip-performance">Performance</span>
          <h3 class="title">“Cuerpo como manifiesto”</h3>
          <p class="meta">CDMX · 2020</p>
        </figcaption>
      </figure>      <!-- 5 más de ejemplo -->
      <figure class="item mural">
        <img src="assets/mural_02.jpg" alt="Mural tipográfico estilo graffiti" loading="lazy">
        <figcaption>
          <span class="chip chip-mural">Mural</span>
          <h3 class="title">“Tipografreak”</h3>
          <p class="meta">Sevilla · 2024</p>
        </figcaption>
      </figure>      <figure class="item protesta">
        <img src="assets/protesta_02.jpg" alt="Manos sosteniendo pancarta verde neón" loading="lazy">
        <figcaption>
          <span class="chip chip-protesta">Protesta</span>
          <h3 class="title">“Manifiesto vivo”</h3>
          <p class="meta">Lima · 2023</p>
        </figcaption>
      </figure>      <figure class="item collage">
        <img src="assets/collage_02.jpg" alt="Collage con revistas y pintura fucsia" loading="lazy">
        <figcaption>
          <span class="chip chip-collage">Collage</span>
          <h3 class="title">“Capa sobre capa”</h3>
          <p class="meta">Lisboa · 2022</p>
        </figcaption>
      </figure>      <figure class="item stencil">
        <img src="assets/stencil_02.jpg" alt="Stencil de megáfono sobre ladrillo" loading="lazy">
        <figcaption>
          <span class="chip chip-stencil">Stencil</span>
          <h3 class="title">“Hazte oír”</h3>
          <p class="meta">Bilbao · 2025</p>
        </figcaption>
      </figure>      <figure class="item performance">
        <img src="assets/performance_02.jpg" alt="Acción callejera con pintura neón" loading="lazy">
        <figcaption>
          <span class="chip chip-performance">Performance</span>
          <h3 class="title">“Ritual urbano”</h3>
          <p class="meta">Bogotá · 2021</p>
        </figcaption>
      </figure>
    </section>    <!-- Sobre -->
    <section id="sobre" class="sobre">
      <h2>Sobre ARTIVISMO</h2>
      <p>
        ARTIVISMO es un espacio para archivar y celebrar imágenes con intención:
        murales, protestas visuales, collages, stencils y performances. Curamos
        piezas que interpelan, conmueven y activan.
      </p>
    </section>    <!-- Contacto -->
    <section id="contacto" class="contacto">
      <h2>Contacto</h2>
      <p>¿Quieres sugerir una obra o colaborar?</p>
      <a class="cta" href="mailto:hola@artivismo.example">hola@artivismo.example</a>
    </section>
  </main>  <footer class="site-footer">
    <p>© <span id="year"></span> ARTIVISMO — hecho con amor, fucsia y neón.</p>
  </footer>  <!-- Año (opcional: si no quieres JS, cambia a texto plano y borra este bloque) -->
  <script>
    document.getElementById('year').textContent = new Date().getFullYear();
  </script>
 </body>
 </html>
--- a/node_modules/.bin/sbot
+++ b/node_modules/.bin/sbot
@ -0,0 +1 @@
 ../ssb-server/bin.js
--- a/node_modules/.bin/ssb-server
+++ b/node_modules/.bin/ssb-server
@ -0,0 +1 @@
 ../ssb-server/bin.js
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
--- a/node_modules/ssb-server/.github/FUNDING.yml
+++ b/node_modules/ssb-server/.github/FUNDING.yml
@ -0,0 +1 @@
 open_collective: secure-scuttlebutt-consortium
--- a/node_modules/ssb-server/.github/stale.yml
+++ b/node_modules/ssb-server/.github/stale.yml
@ -0,0 +1 @@
 _extends: .github
--- a/node_modules/ssb-server/.travis.yml
+++ b/node_modules/ssb-server/.travis.yml
@ -0,0 +1,6 @@
 language: node_js
 sudo: false
 node_js:
  - 8
  - 6
  - 10
--- a/node_modules/ssb-server/README.md
+++ b/node_modules/ssb-server/README.md
@ -0,0 +1,175 @@
 # ssb-server
 ssb-server is an open source **peer-to-peer log store** used as a database, identity provider, and messaging system.
 It has:
 - Global replication
 - File-synchronization
 - End-to-end encryption
 ssb-server behaves just like a [Kappa Architecture DB](http://www.kappa-architecture.com/).
 In the background, it syncs with known peers.
 Peers do not have to be trusted, and can share logs and files on behalf of other peers, as each log is an unforgeable append-only message feed.
 This means ssb-servers comprise a [global gossip-protocol mesh](https://en.wikipedia.org/wiki/Gossip_protocol) without any host dependencies.
 If you are looking to use ssb-server to run a pub, consider using [ssb-minimal-pub-server](https://github.com/ssbc/ssb-minimal-pub-server) instead.
 **Join us in #scuttlebutt on freenode.**
 [![build status](https://secure.travis-ci.org/ssbc/ssb-server.png)](http://travis-ci.org/ssbc/ssb-server)
 ## Install
 a known-working [shrinkwrapped](https://docs.npmjs.com/cli/shrinkwrap.html) version will be installed.
 ```
 npm install -g ssb-server
 ```
 ## Applications
 There are already several applications built on ssb-server,
 one of the best ways to learn about secure-scuttlebutt is to poke around in these applications.
 * [patchwork](http://github.com/ssbc/patchwork) is a discussion platform that we use to anything and everything concerning ssb and decentralization.
 * [patchbay](http://github.com/ssbc/patchbay) is another take on patchwork - it's compatible, less polished, but more modular. The main goal of patchbay is to be very easy to add features to.
 * [git-ssb](https://github.com/clehner/git-ssb) is git (& github!) on top of secure-scuttlebutt. Although we still keep our repos on github, primary development is via git-ssb.
 it is recommended to get started with patchwork, and then look into git-ssb and patchbay.
 ## Example Usage (bash)
 ```bash
 # Start the server with extra log detail
 # Leave this running in its own terminal/window
 ssb-server start --logging.level=info
 # publish a message
 ssb-server publish --type post --text "My First Post!"
 # stream all messages in all feeds, ordered by publish time
 ssb-server feed
 # stream all messages in all feeds, ordered by receive time
 ssb-server log
 # stream all messages by one feed, ordered by sequence number
 ssb-server hist --id $FEED_ID
 ```
 ## Example Usage (js)
 ```js
 var Server = require('ssb-server')
 var config = require('ssb-config')
 var fs = require('fs')
 var path = require('path')
 // add plugins
 Server
  .use(require('ssb-master'))
  .use(require('ssb-gossip'))
  .use(require('ssb-replicate'))
  .use(require('ssb-backlinks'))
 var server = Server(config)
 // save an updated list of methods this server has made public
 // in a location that ssb-client will know to check
 var manifest = server.getManifest()
 fs.writeFileSync(
  path.join(config.path, 'manifest.json'), // ~/.ssb/manifest.json
  JSON.stringify(manifest)
 )
 ```
 see: [github.com/ssbc/**ssb-config**](https://github.com/ssbc/ssb-config) for custom configuration.
 elsewhere: 
 ```js
 var pull = require('pull-stream')
 var Client = require('ssb-client')
 // create a ssb-server client using default settings
 // (server at localhost:8080, using key found at ~/.ssb/secret, and manifest we wrote to `~/.ssb/manifest.json` above)
 Client(function (err, server) {
  if (err) throw err
  // publish a message
  server.publish({ type: 'post', text: 'My First Post!' }, function (err, msg) {
    // msg.key           == hash(msg.value)
    // msg.value.author  == your id
    // msg.value.content == { type: 'post', text: 'My First Post!' }
    // ...
  })
  // stream all messages in all feeds, ordered by publish time
  pull(
    server.createFeedStream(),
    pull.collect(function (err, msgs) {
      // msgs[0].key == hash(msgs[0].value)
      // msgs[0].value...
    })
  )
  // stream all messages in all feeds, ordered by receive time
  pull(
    server.createLogStream(),
    pull.collect(function (err, msgs) {
      // msgs[0].key == hash(msgs[0].value)
      // msgs[0].value...
    })
  )
  // stream all messages by one feed, ordered by sequence number
  pull(
    server.createHistoryStream({ id: < feedId > }),
    pull.collect(function (err, msgs) {
      // msgs[0].key == hash(msgs[0].value)
      // msgs[0].value...
    })
  )
 })
 ```
 ## Use-cases
 ssb-server's message-based data structure makes it ideal for mail and forum applications (see [Patchwork](https://ssbc.github.io/patchwork/)).
 However, it is sufficiently general to be used to build:
 - Office tools (calendars, document-sharing, tasklists)
 - Wikis
 - Package managers
 Because ssb-server doesn't depend on hosts, its users can synchronize over WiFi or any other connective medium, making it great for [Sneakernets](https://en.wikipedia.org/wiki/Sneakernet).
 ssb-server is [eventually-consistent with peers](https://en.wikipedia.org/wiki/Eventual_consistency), and requires exterior coordination to create strictly-ordered transactions.
 Therefore, by itself, it would probably make a poor choice for implementing a crypto-currency.
 (We get asked that a lot.)
 ---
 ### Getting Started
 - [Install](https://ssbc.github.io/docs/scuttlebot/install.html) - Setup instructions
 - [Tutorial](https://ssbc.github.io/docs/scuttlebot/tutorial.html) - Primer on developing with ssb-server
 - [API / CLI Reference](https://scuttlebot.io/apis/scuttlebot/ssb.html) (out of date, but still the best reference)
 - [ssb-config](https://github.com/ssbc/ssb-config) - a module which helps build config to start ssb-server with
 - [ssb-client](https://github.com/ssbc/ssb-client) - make a remote connection to the server
 - [Modules docs](https://modules.scuttlebutt.nz) - see an overview of all the modules
 ### Key Concepts
 - [Secure Scuttlebutt](https://ssbc.github.io/scuttlebutt-protocol-guide/), ssb-server's global database protocol
 - [Content Hash Linking](https://ssbc.github.io/docs/ssb/linking.html)
 - [Secret Handshake](https://ssbc.github.io/docs/ssb/secret-handshake.html), ssb-server's transport-layer security protocol
 - [Private Box](https://ssbc.github.io/docs/ssb/end-to-end-encryption.html), ssb-server's end-to-end security protocol
 - [Frequently Asked Questions](https://ssbc.github.io/docs/ssb/faq.html)
 ### Further Reading
 - [Design Challenge: Avoid Centralization and Singletons](https://ssbc.github.io/docs/articles/design-challenge-avoid-centralization-and-singletons.html)
 - [Design Challenge: Sybil Attacks](https://ssbc.github.io/docs/articles/design-challenge-sybil-attack.html)
 - [Using Trust in Open Networks](https://ssbc.github.io/docs/articles/using-trust-in-open-networks.html)
 # License
 MIT
--- a/node_modules/ssb-server/api.md
+++ b/node_modules/ssb-server/api.md
@ -0,0 +1,341 @@
 # ssb-server
 Secure-scuttlebutt API server
 ## get: async
 Get a message by its hash-id.
 ```bash
 get {msgid}
 ```
 ```js
 get(msgid, cb)
 ```
 ## createFeedStream: source
 (feed) Fetch messages ordered by their claimed timestamps.
 ```bash
 feed [--live] [--gt index] [--gte index] [--lt index] [--lte index] [--reverse]  [--keys] [--values] [--limit n]
 ```
 ```js
 createFeedStream({ live:, gt:, gte:, lt:, lte:, reverse:, keys:, values:, limit:, fillCache:, keyEncoding:, valueEncoding: })
 ```
 Create a stream of the data in the database, ordered by the timestamp claimed by the author.
 NOTE - the timestamp is not verified, and may be incorrect.
 The range queries (gt, gte, lt, lte) filter against this claimed timestap.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `gt` (greater than), `gte` (greater than or equal) define the lower bound of the range to be streamed. Only records where the key is greater than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `lt` (less than), `lte` (less than or equal) define the higher bound of the range to be streamed. Only key/value pairs where the key is less than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `reverse` (boolean, default: `false`): a boolean, set true and the stream output will be reversed. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `true`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 - `limit` (number, default: `-1`): limit the number of results collected by this stream. This number represents a *maximum* number of results and may not be reached if you get to the end of the data first. A value of `-1` means there is no limit. When `reverse=true` the highest keys will be returned instead of the lowest keys.
 - `fillCache` (boolean, default: `false`): wheather LevelDB's LRU-cache should be filled with data read.
 - `keyEncoding` / `valueEncoding` (string): the encoding applied to each read piece of data.
 ## createLogStream: source
 (log) Fetch messages ordered by the time received.
 ```bash
 log [--live] [--gt index] [--gte index] [--lt index] [--lte index] [--reverse]  [--keys] [--values] [--limit n]
 ```
 ```js
 createLogStream({ live:, gt:, gte:, lt:, lte:, reverse:, keys:, values:, limit:, fillCache:, keyEncoding:, valueEncoding: })
 ```
 Creates a stream of the messages that have been written to this instance, in the order they arrived.
 The objects in this stream will be of the form:
 ```
 { key: Hash, value: Message, timestamp: timestamp }
 ```
 `timestamp` is the time which the message was received.
 It is generated by [monotonic-timestamp](https://github.com/dominictarr/monotonic-timestamp).
 The range queries (gt, gte, lt, lte) filter against this receive timestap.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `gt` (greater than), `gte` (greater than or equal) define the lower bound of the range to be streamed. Only records where the key is greater than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `lt` (less than), `lte` (less than or equal) define the higher bound of the range to be streamed. Only key/value pairs where the key is less than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `reverse` (boolean, default: `false`): a boolean, set true and the stream output will be reversed. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `false`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 - `limit` (number, default: `-1`): limit the number of results collected by this stream. This number represents a *maximum* number of results and may not be reached if you get to the end of the data first. A value of `-1` means there is no limit. When `reverse=true` the highest keys will be returned instead of the lowest keys.
 - `fillCache` (boolean, default: `false`): wheather LevelDB's LRU-cache should be filled with data read.
 - `keyEncoding` / `valueEncoding` (string): the encoding applied to each read piece of data.
 ## messagesByType: source
 (logt) Retrieve messages with a given type, ordered by receive-time.
 ```bash
 logt --type {type} [--live] [--gt index] [--gte index] [--lt index] [--lte index] [--reverse]  [--keys] [--values] [--limit n]
 ```
 ```js
 messagesByType({ type:, live:, gt:, gte:, lt:, lte:, reverse:, keys:, values:, limit:, fillCache:, keyEncoding:, valueEncoding: })
 ```
 All messages must have a type, so this is a good way to select messages that an application might use.
 Like in createLogStream, the range queries (gt, gte, lt, lte) filter against the receive timestap.
 - `type` (string): The type of the messages to emit.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `gt` (greater than), `gte` (greater than or equal) define the lower bound of the range to be streamed. Only records where the key is greater than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `lt` (less than), `lte` (less than or equal) define the higher bound of the range to be streamed. Only key/value pairs where the key is less than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `reverse` (boolean, default: `false`): a boolean, set true and the stream output will be reversed. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `true`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 - `limit` (number, default: `-1`): limit the number of results collected by this stream. This number represents a *maximum* number of results and may not be reached if you get to the end of the data first. A value of `-1` means there is no limit. When `reverse=true` the highest keys will be returned instead of the lowest keys.
 - `fillCache` (boolean, default: `false`): wheather LevelDB's LRU-cache should be filled with data read.
 - `keyEncoding` / `valueEncoding` (string): the encoding applied to each read piece of data.
 ## createHistoryStream: source
 (hist) Fetch messages from a specific user, ordered by sequence numbers.
 ```bash
 hist {feedid} [seq] [live]
 hist --id {feedid} [--seq n] [--live] [--limit n] [--keys] [--values]
 ```
 ```js
 createHistoryStream(id, seq, live)
 createHistoryStream({ id:, seq:, live:, limit:, keys:, values: })
 ```
 `createHistoryStream` and `createUserStream` serve the same purpose.
 `createHistoryStream` exists as a separate call because it provides fewer range parameters, which makes it safer for RPC between untrusted peers.
 - `id` (FeedID, required): The id of the feed to fetch.
 - `seq` (number, default: `0`): If `seq > 0`, then only stream messages with sequence numbers greater than `seq`.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `true`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 - `limit` (number, default: `-1`): limit the number of results collected by this stream. This number represents a *maximum* number of results and may not be reached if you get to the end of the data first. A value of `-1` means there is no limit. When `reverse=true` the highest keys will be returned instead of the lowest keys.
 ## createUserStream: source
 Fetch messages from a specific user, ordered by sequence numbers.
 ```bash
 createUserStream --id {feedid} [--live] [--gt index] [--gte index] [--lt index] [--lte index] [--reverse]  [--keys] [--values] [--limit n]
 ```
 ```js
 createUserStream({ id:, live:, gt:, gte:, lt:, lte:, reverse:, keys:, values:, limit:, fillCache:, keyEncoding:, valueEncoding: })
 ```
 `createHistoryStream` and `createUserStream` serve the same purpose.
 `createHistoryStream` exists as a separate call because it provides fewer range parameters, which makes it safer for RPC between untrusted peers.
 The range queries (gt, gte, lt, lte) filter against the sequence number.
 - `id` (FeedID, required): The id of the feed to fetch.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `gt` (greater than), `gte` (greater than or equal) define the lower bound of the range to be streamed. Only records where the key is greater than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `lt` (less than), `lte` (less than or equal) define the higher bound of the range to be streamed. Only key/value pairs where the key is less than (or equal to) this option will be included in the range. When `reverse=true` the order will be reversed, but the records streamed will be the same.
 - `reverse` (boolean, default: `false`): a boolean, set true and the stream output will be reversed. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `true`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 - `limit` (number, default: `-1`): limit the number of results collected by this stream. This number represents a *maximum* number of results and may not be reached if you get to the end of the data first. A value of `-1` means there is no limit. When `reverse=true` the highest keys will be returned instead of the lowest keys.
 - `fillCache` (boolean, default: `false`): wheather LevelDB's LRU-cache should be filled with data read.
 - `keyEncoding` / `valueEncoding` (string): the encoding applied to each read piece of data.
 ## createWriteStream: sink
 write a number of messages to the local store.
 will error if messages are not valid, but will accept
 messages that the ssb-server doesn't replicate.
 ## links: source
 Get a stream of messages, feeds, or blobs that are linked to/from an id.
 ```bash
 links [--source id|filter] [--dest id|filter] [--rel value] [--keys] [--values] [--live] [--reverse]
 ```
 ```js
 links({ source:, dest:, rel:, keys:, values:, live:, reverse: })
 ```
 The objects in this stream will be of the form:
 ```
 { source: ID, rel: String, dest: ID, key: MsgID }
 ```
 - `source` (string, optional): An id or filter, specifying where the link should originate from. To filter, just use the sigil of the type you want: `@` for feeds, `%` for messages, and `&` for blobs.
 - `dest` (string, optional): An id or filter, specifying where the link should point to. To filter, just use the sigil of the type you want: `@` for feeds, `%` for messages, and `&` for blobs.
 - `rel` (string, optional): Filters the links by the relation string.
 - `live` (boolean, default: `false`): Keep the stream open and emit new messages as they are received.
 - `reverse` (boolean, default: `false`): a boolean, set true and the stream output will be reversed. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
 - `keys` (boolean, default: `true`): whether the `data` event should contain keys. If set to `true` and `values` set to `false` then `data` events will simply be keys, rather than objects with a `key` property.
 - `values` (boolean, default: `true`): whether the `data` event should contain values. If set to `true` and `keys` set to `false` then `data` events will simply be values, rather than objects with a `value` property.
 ## add: async
 Add a well-formed message to the database.
 ```bash
 cat ./message.json | add
 add --author {feedid} --sequence {number} --previous {msgid} --timestamp {number} --hash sha256 --signature {sig} --content.type {type} --content.{...}
 ```
 ```js
 add({ author:, sequence:, previous: timestamp:, hash: 'sha256', signature:, content: { type:, ... } }, cb)
 ```
 - `author` (FeedID): Public key of the author of the message.
 - `sequence` (number): Sequence number of the message. (Starts from 1.)
 - `previous` (MsgID): Hash-id of the previous message in the feed (null for seq=1).
 - `timestamp` (number): Unix timestamp for the publish time.
 - `hash` (string): The hash algorithm used in the message, should always be `sha256`.
 - `signature` (string): A signature computed using the author pubkey and the content of the message (less the `signature` attribute).
 - `content` (object): The content of the message.
   - `.type` (string): The object's type.
 ## publish: async
 Construct a message using ssb-server's current user, and add it to the DB.
 ```bash
 cat ./message-content.json | publish
 publish --type {string} [--other-attributes...]
 ```
 ```js
 publish({ type:, ... }, cb)
 ```
 This is the recommended method for publishing new messages, as it handles the tasks of correctly setting the message's timestamp, sequence number, previous-hash, and signature.
 - `content` (object): The content of the message.
   - `.type` (string): The object's type.
 ## getAddress: sync
 Get the address of the server. Default scope is public.
 ```bash
 getAddress {scope}
 ```
 ```js
 getAddress(scope, cb)
 ```
 ## getLatest: async
 Get the latest message in the database by the given feedid.
 ```bash
 getLatest {feedid}
 ```
 ```js
 getLatest(id, cb)
 ```
 ## latest: source
 Get the seq numbers of the latest messages of all users in the database.
 ```bash
 latest
 ```
 ```js
 latest()
 ```
 ## latestSequence: async
 Get the sequence and local timestamp of the last received message from
 a given `feedId`.
 ```bash
 latestSequence {feedId}
 ```
 ```js
 latest({feedId})
 ```
 ## whoami: sync
 Get information about the current ssb-server user.
 ```bash
 whoami
 ```
 ```js
 whoami(cb)
 ```
 Outputs information in the following form:
 ```
 { id: FeedID }
 ```
 ## progress: sync
 returns an object reflecting the progress state of various plugins.
 the return value is a `{}` with subobjects showing `{start,current,target}`
 to represent progress. Currently implemented are `migration` (legacy->flume)
 migration progress and `indexes` (index regeneration).
 ## status: sync
 returns an object reflecting the status of various ssb operations,
 such as db read activity, connection statuses, etc, etc. The purpose is to provide
 an overview of how ssb is working.
 ## getVectorClock: async
 ## version: sync
 return the current version number of the running server
--- a/node_modules/ssb-server/bin.js
+++ b/node_modules/ssb-server/bin.js
@ -0,0 +1,161 @@
 #! /usr/bin/env node
 var fs           = require('fs')
 var path         = require('path')
 var pull         = require('pull-stream')
 var toPull       = require('stream-to-pull-stream')
 var File         = require('pull-file')
 var explain      = require('explain-error')
 var Config       = require('ssb-config/inject')
 var Client       = require('ssb-client')
 var minimist     = require('minimist')
 var muxrpcli     = require('muxrpcli')
 var cmdAliases   = require('./lib/cli-cmd-aliases')
 var ProgressBar  = require('./lib/progress')
 var packageJson  = require('./package.json')
 //get config as cli options after --, options before that are
 //options to the command.
 var argv = process.argv.slice(2)
 var i = argv.indexOf('--')
 var conf = argv.slice(i+1)
 argv = ~i ? argv.slice(0, i) : argv
 var config = Config(process.env.ssb_appname, minimist(conf))
 if (config.keys.curve === 'k256')
  throw new Error('k256 curves are no longer supported,'+
                  'please delete' + path.join(config.path, 'secret'))
 var manifestFile = path.join(config.path, 'manifest.json')
 if (argv[0] == 'server') {
  console.log('WARNING-DEPRECATION: `sbot server` has been renamed to `ssb-server start`')
  argv[0] = 'start'
 }
 if (argv[0] == 'start') {
  console.log(packageJson.name, packageJson.version, config.path, 'logging.level:'+config.logging.level)
  console.log('my key ID:', config.keys.public)
  // special start command:
  // import ssbServer and start the server
  var createSsbServer = require('./')
    .use(require('ssb-onion'))
    .use(require('ssb-unix-socket'))
    .use(require('ssb-no-auth'))
    .use(require('ssb-plugins'))
    .use(require('ssb-master'))
    .use(require('ssb-gossip'))
    .use(require('ssb-replicate'))
    .use(require('ssb-friends'))
    .use(require('ssb-blobs'))
    .use(require('ssb-invite'))
    .use(require('ssb-local'))
    .use(require('ssb-logging'))
    .use(require('ssb-query'))
    .use(require('ssb-links'))
    .use(require('ssb-ws'))
    .use(require('ssb-ebt'))
    .use(require('ssb-ooo'))
  // add third-party plugins
  require('ssb-plugins').loadUserPlugins(createSsbServer, config)
  // start server
  var server = createSsbServer(config)
  // write RPC manifest to ~/.ssb/manifest.json
  fs.writeFileSync(manifestFile, JSON.stringify(server.getManifest(), null, 2))
  if(process.stdout.isTTY && (config.logging.level != 'info'))
    ProgressBar(server.progress)
 } else {
  // normal command:
  // create a client connection to the server
  // read manifest.json
  var manifest
  try {
    manifest = JSON.parse(fs.readFileSync(manifestFile))
  } catch (err) {
    throw explain(err,
      'no manifest file'
      + '- should be generated first time server is run'
    )
  }
  var opts = {
    manifest: manifest,
    port: config.port,
    host: config.host || 'localhost',
    caps: config.caps,
    key: config.key || config.keys.id
  }
  // connect
  Client(config.keys, opts, function (err, rpc) {
    if(err) {
      if (/could not connect/.test(err.message)) {
        console.error('Error: Could not connect to ssb-server ' + opts.host + ':' + opts.port)
        console.error('Use the "start" command to start it.')
        console.error('Use --verbose option to see full error')
        if(config.verbose) throw err
        process.exit(1)
      }
      throw err
    }
    // add aliases
    for (var k in cmdAliases) {
      rpc[k] = rpc[cmdAliases[k]]
      manifest[k] = manifest[cmdAliases[k]]
    }
    // add some extra commands
 //    manifest.version = 'async'
    manifest.config = 'sync'
 //    rpc.version = function (cb) {
 //      console.log(packageJson.version)
 //      cb()
 //    }
    rpc.config = function (cb) {
      console.log(JSON.stringify(config, null, 2))
      cb()
    }
    if (process.argv[2] === 'blobs.add') {
      var filename = process.argv[3]
      var source =
        filename ? File(process.argv[3])
      : !process.stdin.isTTY ? toPull.source(process.stdin)
      : (function () {
        console.error('USAGE:')
        console.error('  blobs.add <filename> # add a file')
        console.error('  source | blobs.add   # read from stdin')
        process.exit(1)
      })()
      pull(
        source,
        rpc.blobs.add(null, function (err, hash) {
          if (err)
            throw err
          console.log(hash)
          process.exit()
        })
      )
      return
    }
    // run commandline flow
    muxrpcli(argv, manifest, rpc, config.verbose)
  })
 }
--- a/node_modules/ssb-server/index.js
+++ b/node_modules/ssb-server/index.js
@ -0,0 +1,16 @@
 var SecretStack = require('secret-stack')
 var caps = require('ssb-caps')
 var SSB = require('ssb-db')
 //create a sbot with default caps. these can be overridden again when you call create.
 function createSsbServer () {
  return SecretStack({ caps }).use(SSB)
 }
 module.exports = createSsbServer()
 //this isn't really needed anymore.
 module.exports.createSsbServer = createSsbServer
--- a/node_modules/ssb-server/lib/cli-cmd-aliases.js
+++ b/node_modules/ssb-server/lib/cli-cmd-aliases.js
@ -0,0 +1,10 @@
 module.exports = {
  feed: 'createFeedStream',
  history: 'createHistoryStream',
  hist: 'createHistoryStream',
  public: 'getPublicKey',
  pub: 'getPublicKey',
  log: 'createLogStream',
  logt: 'messagesByType',
  conf: 'config'
 }
--- a/node_modules/ssb-server/lib/progress.js
+++ b/node_modules/ssb-server/lib/progress.js
@ -0,0 +1,47 @@
 //poll the progress() function and report how much waiting there is...
 //just whipped this up, obviously room for improvement here.
 module.exports = function (progress) {
  function bar (r) {
    var s = '\r', M = 50
    for(var i = 0; i < M; i++)
      s += i < M*r ? '*' : '.'
    return s
  }
  function round (n, p) {
    return Math.round(n * p) / p
  }
  function percent (n) {
    return (round(n, 1000)*100).toString().substring(0, 4)+'%'
  }
  function rate (prog) {
    if(prog.target == prog.current) return 1
    return (prog.current - prog.start) / (prog.target - prog.start)
  }
  var prog = -1
  var int = setInterval(function () {
    var p = progress()
    var r = 1, c = 0
    var tasks = []
    for(var k in p) {
      var _r = rate(p[k])
      if(_r < 1)
        tasks.push(k+':'+percent(_r))
      r = Math.min(_r, r)
      c++
    }
    if(r != prog) {
      prog = r
      var msg = tasks.join(', ')
      process.stdout.write('\r'+bar(prog) + ' ('+msg+')\x1b[K\r')
    }
  }, 333)
  int.unref && int.unref()
 }
--- a/node_modules/ssb-server/lib/validators.js
+++ b/node_modules/ssb-server/lib/validators.js
@ -0,0 +1,239 @@
 var valid = require('muxrpc-validation')
 var zerr  = require('zerr')
 var ref   = require('ssb-ref')
 // errors
 var MissingAttr = zerr('Usage', 'Param % must have a .% of type "%"')
 var AttrType = zerr('Usage', '.% of param % must be of type "%"')
 function isFilter (v) {
  return (v == '@' || v == '%' || v == '&')
 }
 module.exports = valid({
  msgId: function (v) {
    if (!ref.isMsg(v))
      return 'type'
  },
  msgLink: function (v) {
    if (!ref.isMsgLink(v))
      return 'type'
  },
  feedId: function (v) {
    if (!ref.isFeed(v))
      return 'type'
  },
  blobId: function (v) {
    if (!ref.isBlob(v))
      return 'type'
  },
  msgContent: function (v, n) {
    var err = this.get('object')(v, n)
    if (err) return err
    if (!v.type || typeof v.type != 'string')
      return MissingAttr(n, 'type', 'string')
  },
  msg: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err
    //allow content to be string. (i.e. for encrypted messages)
    //or object with type string
    if(!v.content)
      return MissingAttr(n, 'content', 'object|string')
    else if(typeof v.content === 'string')
      ; //check if it's base64?
    else if('object' === typeof v.content) {
      if(!v.content.type || typeof v.content.type != 'string')
      return MissingAttr(n, 'content.type', 'string')
    }
    else
      return MissingAttr(n, 'content', 'object|string')
    // .author
    if (!ref.isFeed(v.author))
      return MissingAttr(n, 'author', 'feedId')
    // .sequence
    if (typeof v.sequence != 'number')
      return MissingAttr(n, 'sequence', 'number')
    // .previous
    if (v.sequence > 1 && !ref.isMsg(v.previous))
      return MissingAttr(n, 'previous', 'msgId')
    else if(v.sequence == 1 && v.previous != null)
      return MissingAttr(n, 'previous', 'null')
    // .timestamp
    if (typeof v.timestamp != 'number')
      return MissingAttr(n, 'timestamp', 'number')
    // .hash
    if (v.hash != 'sha256')
      return zerr('Usage', 'Param % must have .hash set to "sha256"')(n)
    // .signature
    if (typeof v.signature != 'string')
      return MissingAttr(n, 'signature', 'string')
  },
  readStreamOpts: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err
    // .live
    if (v.live && typeof v.live != 'boolean' && typeof v.live != 'number')
      return AttrType(n, 'live', 'boolean')
    // .reverse
    if (v.reverse && typeof v.reverse != 'boolean' && typeof v.reverse != 'number')
      return AttrType(n, 'reverse', 'boolean')
    // .keys
    if (v.keys && typeof v.keys != 'boolean' && typeof v.keys != 'number')
      return AttrType(n, 'keys', 'boolean')
    // .values
    if (v.values && typeof v.values != 'boolean' && typeof v.values != 'number')
      return AttrType(n, 'values', 'boolean')
    // .limit
    if (v.limit && typeof v.limit != 'number')
      return AttrType(n, 'limit', 'number')
    // .fillCache
    if (v.fillCache && typeof v.fillCache != 'boolean' && typeof v.fillCache != 'number')
      return AttrType(n, 'fillCache', 'boolean')
  },
  createHistoryStreamOpts: function (v, n) {
    // .id
    if (!ref.isFeed(v.id))
      return MissingAttr(n, 'id', 'feedId')
    // .seq
    if (v.seq && typeof v.seq != 'number')
      return AttrType(n, 'seq', 'number')
    // .live
    if (v.live && typeof v.live != 'boolean' && typeof v.live != 'number')
      return AttrType(n, 'live', 'boolean')
    // .limit
    if (v.limit && typeof v.limit != 'number')
      return AttrType(n, 'limit', 'number')
    // .keys
    if (v.keys && typeof v.keys != 'boolean' && typeof v.keys != 'number')
      return AttrType(n, 'keys', 'boolean')
    // .values
    if (v.values && typeof v.values != 'boolean' && typeof v.values != 'number')
      return AttrType(n, 'values', 'boolean')
  },
  createUserStreamOpts: function (v, n) {
    var err = this.get('readStreamOpts')(v, n)
    if (err)
      return err
    // .id
    if (!ref.isFeed(v.id))
      return MissingAttr(n, 'id', 'feedId')
  },
  messagesByTypeOpts: function (v, n) {
    var err = this.get('readStreamOpts')(v, n)
    if (err)
      return err
    // .type
    if (typeof v.type != 'string')
      return MissingAttr(n, 'type', 'string')
  },
  linksOpts: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err
    // .source
    if (v.source && !ref.isLink(v.source) && !isFilter(v.source))
      return AttrType(n, 'source', 'id|filter')
    // .dest
    if (v.dest && !ref.isLink(v.dest) && !isFilter(v.dest))
      return AttrType(n, 'dest', 'id|filter')
    // .rel
    if (v.rel && typeof v.rel != 'string')
      return AttrType(n, 'rel', 'string')
    // .live
    if (v.live && typeof v.live != 'boolean' && typeof v.live != 'number')
      return AttrType(n, 'live', 'boolean')
    // .reverse
    if (v.reverse && typeof v.reverse != 'boolean' && typeof v.reverse != 'number')
      return AttrType(n, 'reverse', 'boolean')
    // .keys
    if (v.keys && typeof v.keys != 'boolean' && typeof v.keys != 'number')
      return AttrType(n, 'keys', 'boolean')
    // .values
    if (v.values && typeof v.values != 'boolean' && typeof v.values != 'number')
      return AttrType(n, 'values', 'boolean')
  },
  isBlockedOpts: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err
    // .source
    if (v.source && !ref.isFeed(v.source))
      return AttrType(n, 'source', 'feedId')
    // .dest
    if (v.dest && !ref.isFeed(v.dest))
      return AttrType(n, 'dest', 'feedId')
  },
  createFriendStreamOpts: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err
    // .start
    if (v.start && !ref.isFeed(v.start))
      return AttrType(n, 'start', 'feedId')
    // .graph
    if (v.graph && typeof v.graph != 'string')
      return AttrType(n, 'graph', 'string')
    // .dunbar
    if (v.dunbar && typeof v.dunbar != 'number')
      return AttrType(n, 'dunbar', 'number')
    // .hops
    if (v.hops && typeof v.hops != 'number')
      return AttrType(n, 'hops', 'number')
  }
 })
--- a/node_modules/ssb-server/node_modules/@babel/code-frame/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/code-frame/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/code-frame/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/code-frame/README.md
@ -0,0 +1,19 @@
 # @babel/code-frame
 > Generate errors that contain a code frame that point to source locations.
 See our website [@babel/code-frame](https://babeljs.io/docs/en/next/babel-code-frame.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/code-frame
 ```
 or using yarn:
 ```sh
 yarn add @babel/code-frame --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/code-frame/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/code-frame/lib/index.js
@ -0,0 +1,167 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.codeFrameColumns = codeFrameColumns;
 exports.default = _default;
 var _highlight = _interopRequireWildcard(require("@babel/highlight"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 let deprecationWarningShown = false;
 function getDefs(chalk) {
  return {
    gutter: chalk.grey,
    marker: chalk.red.bold,
    message: chalk.red.bold
  };
 }
 const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 function getMarkerLines(loc, source, opts) {
  const startLoc = Object.assign({
    column: 0,
    line: -1
  }, loc.start);
  const endLoc = Object.assign({}, startLoc, {}, loc.end);
  const {
    linesAbove = 2,
    linesBelow = 3
  } = opts || {};
  const startLine = startLoc.line;
  const startColumn = startLoc.column;
  const endLine = endLoc.line;
  const endColumn = endLoc.column;
  let start = Math.max(startLine - (linesAbove + 1), 0);
  let end = Math.min(source.length, endLine + linesBelow);
  if (startLine === -1) {
    start = 0;
  }
  if (endLine === -1) {
    end = source.length;
  }
  const lineDiff = endLine - startLine;
  const markerLines = {};
  if (lineDiff) {
    for (let i = 0; i <= lineDiff; i++) {
      const lineNumber = i + startLine;
      if (!startColumn) {
        markerLines[lineNumber] = true;
      } else if (i === 0) {
        const sourceLength = source[lineNumber - 1].length;
        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
      } else if (i === lineDiff) {
        markerLines[lineNumber] = [0, endColumn];
      } else {
        const sourceLength = source[lineNumber - i].length;
        markerLines[lineNumber] = [0, sourceLength];
      }
    }
  } else {
    if (startColumn === endColumn) {
      if (startColumn) {
        markerLines[startLine] = [startColumn, 0];
      } else {
        markerLines[startLine] = true;
      }
    } else {
      markerLines[startLine] = [startColumn, endColumn - startColumn];
    }
  }
  return {
    start,
    end,
    markerLines
  };
 }
 function codeFrameColumns(rawLines, loc, opts = {}) {
  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
  const chalk = (0, _highlight.getChalk)(opts);
  const defs = getDefs(chalk);
  const maybeHighlight = (chalkFn, string) => {
    return highlighted ? chalkFn(string) : string;
  };
  const lines = rawLines.split(NEWLINE);
  const {
    start,
    end,
    markerLines
  } = getMarkerLines(loc, lines, opts);
  const hasColumns = loc.start && typeof loc.start.column === "number";
  const numberMaxWidth = String(end).length;
  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
  let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
    const number = start + 1 + index;
    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
    const gutter = ` ${paddedNumber} | `;
    const hasMarker = markerLines[number];
    const lastMarkerLine = !markerLines[number + 1];
    if (hasMarker) {
      let markerLine = "";
      if (Array.isArray(hasMarker)) {
        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
        const numberOfMarkers = hasMarker[1] || 1;
        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
        if (lastMarkerLine && opts.message) {
          markerLine += " " + maybeHighlight(defs.message, opts.message);
        }
      }
      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
    } else {
      return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
    }
  }).join("\n");
  if (opts.message && !hasColumns) {
    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
  }
  if (highlighted) {
    return chalk.reset(frame);
  } else {
    return frame;
  }
 }
 function _default(rawLines, lineNumber, colNumber, opts = {}) {
  if (!deprecationWarningShown) {
    deprecationWarningShown = true;
    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
    if (process.emitWarning) {
      process.emitWarning(message, "DeprecationWarning");
    } else {
      const deprecationError = new Error(message);
      deprecationError.name = "DeprecationWarning";
      console.warn(new Error(message));
    }
  }
  colNumber = Math.max(colNumber, 0);
  const location = {
    start: {
      column: colNumber,
      line: lineNumber
    }
  };
  return codeFrameColumns(rawLines, location, opts);
 }
--- a/node_modules/ssb-server/node_modules/@babel/code-frame/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/code-frame/package.json
@ -0,0 +1,21 @@
 {
  "name": "@babel/code-frame",
  "version": "7.8.3",
  "description": "Generate errors that contain a code frame that point to source locations.",
  "author": "Sebastian McKenzie <sebmck@gmail.com>",
  "homepage": "https://babeljs.io/",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-code-frame",
  "main": "lib/index.js",
  "dependencies": {
    "@babel/highlight": "^7.8.3"
  },
  "devDependencies": {
    "chalk": "^2.0.0",
    "strip-ansi": "^4.0.0"
  },
  "gitHead": "a7620bd266ae1345975767bbc7abf09034437017"
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/generator/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/generator/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/generator/README.md
@ -0,0 +1,19 @@
 # @babel/generator
 > Turns an AST into code.
 See our website [@babel/generator](https://babeljs.io/docs/en/next/babel-generator.html) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen) associated with this package.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/generator
 ```
 or using yarn:
 ```sh
 yarn add @babel/generator --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/buffer.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/buffer.js
@ -0,0 +1,244 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = void 0;
 const SPACES_RE = /^[ \t]+$/;
 class Buffer {
  constructor(map) {
    this._map = null;
    this._buf = [];
    this._last = "";
    this._queue = [];
    this._position = {
      line: 1,
      column: 0
    };
    this._sourcePosition = {
      identifierName: null,
      line: null,
      column: null,
      filename: null
    };
    this._disallowedPop = null;
    this._map = map;
  }
  get() {
    this._flush();
    const map = this._map;
    const result = {
      code: this._buf.join("").trimRight(),
      map: null,
      rawMappings: map && map.getRawMappings()
    };
    if (map) {
      Object.defineProperty(result, "map", {
        configurable: true,
        enumerable: true,
        get() {
          return this.map = map.get();
        },
        set(value) {
          Object.defineProperty(this, "map", {
            value,
            writable: true
          });
        }
      });
    }
    return result;
  }
  append(str) {
    this._flush();
    const {
      line,
      column,
      filename,
      identifierName,
      force
    } = this._sourcePosition;
    this._append(str, line, column, identifierName, filename, force);
  }
  queue(str) {
    if (str === "\n") {
      while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
        this._queue.shift();
      }
    }
    const {
      line,
      column,
      filename,
      identifierName,
      force
    } = this._sourcePosition;
    this._queue.unshift([str, line, column, identifierName, filename, force]);
  }
  _flush() {
    let item;
    while (item = this._queue.pop()) this._append(...item);
  }
  _append(str, line, column, identifierName, filename, force) {
    if (this._map && str[0] !== "\n") {
      this._map.mark(this._position.line, this._position.column, line, column, identifierName, filename, force);
    }
    this._buf.push(str);
    this._last = str[str.length - 1];
    for (let i = 0; i < str.length; i++) {
      if (str[i] === "\n") {
        this._position.line++;
        this._position.column = 0;
      } else {
        this._position.column++;
      }
    }
  }
  removeTrailingNewline() {
    if (this._queue.length > 0 && this._queue[0][0] === "\n") {
      this._queue.shift();
    }
  }
  removeLastSemicolon() {
    if (this._queue.length > 0 && this._queue[0][0] === ";") {
      this._queue.shift();
    }
  }
  endsWith(suffix) {
    if (suffix.length === 1) {
      let last;
      if (this._queue.length > 0) {
        const str = this._queue[0][0];
        last = str[str.length - 1];
      } else {
        last = this._last;
      }
      return last === suffix;
    }
    const end = this._last + this._queue.reduce((acc, item) => item[0] + acc, "");
    if (suffix.length <= end.length) {
      return end.slice(-suffix.length) === suffix;
    }
    return false;
  }
  hasContent() {
    return this._queue.length > 0 || !!this._last;
  }
  exactSource(loc, cb) {
    this.source("start", loc, true);
    cb();
    this.source("end", loc);
    this._disallowPop("start", loc);
  }
  source(prop, loc, force) {
    if (prop && !loc) return;
    this._normalizePosition(prop, loc, this._sourcePosition, force);
  }
  withSource(prop, loc, cb) {
    if (!this._map) return cb();
    const originalLine = this._sourcePosition.line;
    const originalColumn = this._sourcePosition.column;
    const originalFilename = this._sourcePosition.filename;
    const originalIdentifierName = this._sourcePosition.identifierName;
    this.source(prop, loc);
    cb();
    if ((!this._sourcePosition.force || this._sourcePosition.line !== originalLine || this._sourcePosition.column !== originalColumn || this._sourcePosition.filename !== originalFilename) && (!this._disallowedPop || this._disallowedPop.line !== originalLine || this._disallowedPop.column !== originalColumn || this._disallowedPop.filename !== originalFilename)) {
      this._sourcePosition.line = originalLine;
      this._sourcePosition.column = originalColumn;
      this._sourcePosition.filename = originalFilename;
      this._sourcePosition.identifierName = originalIdentifierName;
      this._sourcePosition.force = false;
      this._disallowedPop = null;
    }
  }
  _disallowPop(prop, loc) {
    if (prop && !loc) return;
    this._disallowedPop = this._normalizePosition(prop, loc);
  }
  _normalizePosition(prop, loc, targetObj, force) {
    const pos = loc ? loc[prop] : null;
    if (targetObj === undefined) {
      targetObj = {
        identifierName: null,
        line: null,
        column: null,
        filename: null,
        force: false
      };
    }
    const origLine = targetObj.line;
    const origColumn = targetObj.column;
    const origFilename = targetObj.filename;
    targetObj.identifierName = prop === "start" && loc && loc.identifierName || null;
    targetObj.line = pos ? pos.line : null;
    targetObj.column = pos ? pos.column : null;
    targetObj.filename = loc && loc.filename || null;
    if (force || targetObj.line !== origLine || targetObj.column !== origColumn || targetObj.filename !== origFilename) {
      targetObj.force = force;
    }
    return targetObj;
  }
  getCurrentColumn() {
    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
    const lastIndex = extra.lastIndexOf("\n");
    return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex;
  }
  getCurrentLine() {
    const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
    let count = 0;
    for (let i = 0; i < extra.length; i++) {
      if (extra[i] === "\n") count++;
    }
    return this._position.line + count;
  }
 }
 exports.default = Buffer;
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/base.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/base.js
@ -0,0 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.File = File;
 exports.Program = Program;
 exports.BlockStatement = BlockStatement;
 exports.Noop = Noop;
 exports.Directive = Directive;
 exports.DirectiveLiteral = DirectiveLiteral;
 exports.InterpreterDirective = InterpreterDirective;
 exports.Placeholder = Placeholder;
 function File(node) {
  if (node.program) {
    this.print(node.program.interpreter, node);
  }
  this.print(node.program, node);
 }
 function Program(node) {
  this.printInnerComments(node, false);
  this.printSequence(node.directives, node);
  if (node.directives && node.directives.length) this.newline();
  this.printSequence(node.body, node);
 }
 function BlockStatement(node) {
  this.token("{");
  this.printInnerComments(node);
  const hasDirectives = node.directives && node.directives.length;
  if (node.body.length || hasDirectives) {
    this.newline();
    this.printSequence(node.directives, node, {
      indent: true
    });
    if (hasDirectives) this.newline();
    this.printSequence(node.body, node, {
      indent: true
    });
    this.removeTrailingNewline();
    this.source("end", node.loc);
    if (!this.endsWith("\n")) this.newline();
    this.rightBrace();
  } else {
    this.source("end", node.loc);
    this.token("}");
  }
 }
 function Noop() {}
 function Directive(node) {
  this.print(node.value, node);
  this.semicolon();
 }
 const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
 const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
 function DirectiveLiteral(node) {
  const raw = this.getPossibleRaw(node);
  if (raw != null) {
    this.token(raw);
    return;
  }
  const {
    value
  } = node;
  if (!unescapedDoubleQuoteRE.test(value)) {
    this.token(`"${value}"`);
  } else if (!unescapedSingleQuoteRE.test(value)) {
    this.token(`'${value}'`);
  } else {
    throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes.");
  }
 }
 function InterpreterDirective(node) {
  this.token(`#!${node.value}\n`);
 }
 function Placeholder(node) {
  this.token("%%");
  this.print(node.name);
  this.token("%%");
  if (node.expectedNode === "Statement") {
    this.semicolon();
  }
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/classes.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/classes.js
@ -0,0 +1,151 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
 exports.ClassBody = ClassBody;
 exports.ClassProperty = ClassProperty;
 exports.ClassPrivateProperty = ClassPrivateProperty;
 exports.ClassMethod = ClassMethod;
 exports.ClassPrivateMethod = ClassPrivateMethod;
 exports._classMethodHead = _classMethodHead;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function ClassDeclaration(node, parent) {
  if (!this.format.decoratorsBeforeExport || !t.isExportDefaultDeclaration(parent) && !t.isExportNamedDeclaration(parent)) {
    this.printJoin(node.decorators, node);
  }
  if (node.declare) {
    this.word("declare");
    this.space();
  }
  if (node.abstract) {
    this.word("abstract");
    this.space();
  }
  this.word("class");
  if (node.id) {
    this.space();
    this.print(node.id, node);
  }
  this.print(node.typeParameters, node);
  if (node.superClass) {
    this.space();
    this.word("extends");
    this.space();
    this.print(node.superClass, node);
    this.print(node.superTypeParameters, node);
  }
  if (node.implements) {
    this.space();
    this.word("implements");
    this.space();
    this.printList(node.implements, node);
  }
  this.space();
  this.print(node.body, node);
 }
 function ClassBody(node) {
  this.token("{");
  this.printInnerComments(node);
  if (node.body.length === 0) {
    this.token("}");
  } else {
    this.newline();
    this.indent();
    this.printSequence(node.body, node);
    this.dedent();
    if (!this.endsWith("\n")) this.newline();
    this.rightBrace();
  }
 }
 function ClassProperty(node) {
  this.printJoin(node.decorators, node);
  this.tsPrintClassMemberModifiers(node, true);
  if (node.computed) {
    this.token("[");
    this.print(node.key, node);
    this.token("]");
  } else {
    this._variance(node);
    this.print(node.key, node);
  }
  if (node.optional) {
    this.token("?");
  }
  if (node.definite) {
    this.token("!");
  }
  this.print(node.typeAnnotation, node);
  if (node.value) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.value, node);
  }
  this.semicolon();
 }
 function ClassPrivateProperty(node) {
  if (node.static) {
    this.word("static");
    this.space();
  }
  this.print(node.key, node);
  this.print(node.typeAnnotation, node);
  if (node.value) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.value, node);
  }
  this.semicolon();
 }
 function ClassMethod(node) {
  this._classMethodHead(node);
  this.space();
  this.print(node.body, node);
 }
 function ClassPrivateMethod(node) {
  this._classMethodHead(node);
  this.space();
  this.print(node.body, node);
 }
 function _classMethodHead(node) {
  this.printJoin(node.decorators, node);
  this.tsPrintClassMemberModifiers(node, false);
  this._methodHead(node);
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/expressions.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/expressions.js
@ -0,0 +1,292 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.UnaryExpression = UnaryExpression;
 exports.DoExpression = DoExpression;
 exports.ParenthesizedExpression = ParenthesizedExpression;
 exports.UpdateExpression = UpdateExpression;
 exports.ConditionalExpression = ConditionalExpression;
 exports.NewExpression = NewExpression;
 exports.SequenceExpression = SequenceExpression;
 exports.ThisExpression = ThisExpression;
 exports.Super = Super;
 exports.Decorator = Decorator;
 exports.OptionalMemberExpression = OptionalMemberExpression;
 exports.OptionalCallExpression = OptionalCallExpression;
 exports.CallExpression = CallExpression;
 exports.Import = Import;
 exports.EmptyStatement = EmptyStatement;
 exports.ExpressionStatement = ExpressionStatement;
 exports.AssignmentPattern = AssignmentPattern;
 exports.LogicalExpression = exports.BinaryExpression = exports.AssignmentExpression = AssignmentExpression;
 exports.BindExpression = BindExpression;
 exports.MemberExpression = MemberExpression;
 exports.MetaProperty = MetaProperty;
 exports.PrivateName = PrivateName;
 exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
 exports.AwaitExpression = exports.YieldExpression = void 0;
 var t = _interopRequireWildcard(require("@babel/types"));
 var n = _interopRequireWildcard(require("../node"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function UnaryExpression(node) {
  if (node.operator === "void" || node.operator === "delete" || node.operator === "typeof" || node.operator === "throw") {
    this.word(node.operator);
    this.space();
  } else {
    this.token(node.operator);
  }
  this.print(node.argument, node);
 }
 function DoExpression(node) {
  this.word("do");
  this.space();
  this.print(node.body, node);
 }
 function ParenthesizedExpression(node) {
  this.token("(");
  this.print(node.expression, node);
  this.token(")");
 }
 function UpdateExpression(node) {
  if (node.prefix) {
    this.token(node.operator);
    this.print(node.argument, node);
  } else {
    this.startTerminatorless(true);
    this.print(node.argument, node);
    this.endTerminatorless();
    this.token(node.operator);
  }
 }
 function ConditionalExpression(node) {
  this.print(node.test, node);
  this.space();
  this.token("?");
  this.space();
  this.print(node.consequent, node);
  this.space();
  this.token(":");
  this.space();
  this.print(node.alternate, node);
 }
 function NewExpression(node, parent) {
  this.word("new");
  this.space();
  this.print(node.callee, node);
  if (this.format.minified && node.arguments.length === 0 && !node.optional && !t.isCallExpression(parent, {
    callee: node
  }) && !t.isMemberExpression(parent) && !t.isNewExpression(parent)) {
    return;
  }
  this.print(node.typeArguments, node);
  this.print(node.typeParameters, node);
  if (node.optional) {
    this.token("?.");
  }
  this.token("(");
  this.printList(node.arguments, node);
  this.token(")");
 }
 function SequenceExpression(node) {
  this.printList(node.expressions, node);
 }
 function ThisExpression() {
  this.word("this");
 }
 function Super() {
  this.word("super");
 }
 function Decorator(node) {
  this.token("@");
  this.print(node.expression, node);
  this.newline();
 }
 function OptionalMemberExpression(node) {
  this.print(node.object, node);
  if (!node.computed && t.isMemberExpression(node.property)) {
    throw new TypeError("Got a MemberExpression for MemberExpression property");
  }
  let computed = node.computed;
  if (t.isLiteral(node.property) && typeof node.property.value === "number") {
    computed = true;
  }
  if (node.optional) {
    this.token("?.");
  }
  if (computed) {
    this.token("[");
    this.print(node.property, node);
    this.token("]");
  } else {
    if (!node.optional) {
      this.token(".");
    }
    this.print(node.property, node);
  }
 }
 function OptionalCallExpression(node) {
  this.print(node.callee, node);
  this.print(node.typeArguments, node);
  this.print(node.typeParameters, node);
  if (node.optional) {
    this.token("?.");
  }
  this.token("(");
  this.printList(node.arguments, node);
  this.token(")");
 }
 function CallExpression(node) {
  this.print(node.callee, node);
  this.print(node.typeArguments, node);
  this.print(node.typeParameters, node);
  this.token("(");
  this.printList(node.arguments, node);
  this.token(")");
 }
 function Import() {
  this.word("import");
 }
 function buildYieldAwait(keyword) {
  return function (node) {
    this.word(keyword);
    if (node.delegate) {
      this.token("*");
    }
    if (node.argument) {
      this.space();
      const terminatorState = this.startTerminatorless();
      this.print(node.argument, node);
      this.endTerminatorless(terminatorState);
    }
  };
 }
 const YieldExpression = buildYieldAwait("yield");
 exports.YieldExpression = YieldExpression;
 const AwaitExpression = buildYieldAwait("await");
 exports.AwaitExpression = AwaitExpression;
 function EmptyStatement() {
  this.semicolon(true);
 }
 function ExpressionStatement(node) {
  this.print(node.expression, node);
  this.semicolon();
 }
 function AssignmentPattern(node) {
  this.print(node.left, node);
  if (node.left.optional) this.token("?");
  this.print(node.left.typeAnnotation, node);
  this.space();
  this.token("=");
  this.space();
  this.print(node.right, node);
 }
 function AssignmentExpression(node, parent) {
  const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
  if (parens) {
    this.token("(");
  }
  this.print(node.left, node);
  this.space();
  if (node.operator === "in" || node.operator === "instanceof") {
    this.word(node.operator);
  } else {
    this.token(node.operator);
  }
  this.space();
  this.print(node.right, node);
  if (parens) {
    this.token(")");
  }
 }
 function BindExpression(node) {
  this.print(node.object, node);
  this.token("::");
  this.print(node.callee, node);
 }
 function MemberExpression(node) {
  this.print(node.object, node);
  if (!node.computed && t.isMemberExpression(node.property)) {
    throw new TypeError("Got a MemberExpression for MemberExpression property");
  }
  let computed = node.computed;
  if (t.isLiteral(node.property) && typeof node.property.value === "number") {
    computed = true;
  }
  if (computed) {
    this.token("[");
    this.print(node.property, node);
    this.token("]");
  } else {
    this.token(".");
    this.print(node.property, node);
  }
 }
 function MetaProperty(node) {
  this.print(node.meta, node);
  this.token(".");
  this.print(node.property, node);
 }
 function PrivateName(node) {
  this.token("#");
  this.print(node.id, node);
 }
 function V8IntrinsicIdentifier(node) {
  this.token("%");
  this.word(node.name);
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/flow.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/flow.js
@ -0,0 +1,748 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.AnyTypeAnnotation = AnyTypeAnnotation;
 exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
 exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
 exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
 exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
 exports.DeclareClass = DeclareClass;
 exports.DeclareFunction = DeclareFunction;
 exports.InferredPredicate = InferredPredicate;
 exports.DeclaredPredicate = DeclaredPredicate;
 exports.DeclareInterface = DeclareInterface;
 exports.DeclareModule = DeclareModule;
 exports.DeclareModuleExports = DeclareModuleExports;
 exports.DeclareTypeAlias = DeclareTypeAlias;
 exports.DeclareOpaqueType = DeclareOpaqueType;
 exports.DeclareVariable = DeclareVariable;
 exports.DeclareExportDeclaration = DeclareExportDeclaration;
 exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
 exports.EnumDeclaration = EnumDeclaration;
 exports.EnumBooleanBody = EnumBooleanBody;
 exports.EnumNumberBody = EnumNumberBody;
 exports.EnumStringBody = EnumStringBody;
 exports.EnumSymbolBody = EnumSymbolBody;
 exports.EnumDefaultedMember = EnumDefaultedMember;
 exports.EnumBooleanMember = EnumBooleanMember;
 exports.EnumNumberMember = EnumNumberMember;
 exports.EnumStringMember = EnumStringMember;
 exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
 exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
 exports.FunctionTypeParam = FunctionTypeParam;
 exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
 exports._interfaceish = _interfaceish;
 exports._variance = _variance;
 exports.InterfaceDeclaration = InterfaceDeclaration;
 exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
 exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
 exports.MixedTypeAnnotation = MixedTypeAnnotation;
 exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
 exports.NullableTypeAnnotation = NullableTypeAnnotation;
 exports.NumberTypeAnnotation = NumberTypeAnnotation;
 exports.StringTypeAnnotation = StringTypeAnnotation;
 exports.ThisTypeAnnotation = ThisTypeAnnotation;
 exports.TupleTypeAnnotation = TupleTypeAnnotation;
 exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
 exports.TypeAlias = TypeAlias;
 exports.TypeAnnotation = TypeAnnotation;
 exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
 exports.TypeParameter = TypeParameter;
 exports.OpaqueType = OpaqueType;
 exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
 exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
 exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
 exports.ObjectTypeIndexer = ObjectTypeIndexer;
 exports.ObjectTypeProperty = ObjectTypeProperty;
 exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
 exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
 exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
 exports.UnionTypeAnnotation = UnionTypeAnnotation;
 exports.TypeCastExpression = TypeCastExpression;
 exports.Variance = Variance;
 exports.VoidTypeAnnotation = VoidTypeAnnotation;
 Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
  enumerable: true,
  get: function () {
    return _types2.NumericLiteral;
  }
 });
 Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
  enumerable: true,
  get: function () {
    return _types2.StringLiteral;
  }
 });
 var t = _interopRequireWildcard(require("@babel/types"));
 var _modules = require("./modules");
 var _types2 = require("./types");
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function AnyTypeAnnotation() {
  this.word("any");
 }
 function ArrayTypeAnnotation(node) {
  this.print(node.elementType, node);
  this.token("[");
  this.token("]");
 }
 function BooleanTypeAnnotation() {
  this.word("boolean");
 }
 function BooleanLiteralTypeAnnotation(node) {
  this.word(node.value ? "true" : "false");
 }
 function NullLiteralTypeAnnotation() {
  this.word("null");
 }
 function DeclareClass(node, parent) {
  if (!t.isDeclareExportDeclaration(parent)) {
    this.word("declare");
    this.space();
  }
  this.word("class");
  this.space();
  this._interfaceish(node);
 }
 function DeclareFunction(node, parent) {
  if (!t.isDeclareExportDeclaration(parent)) {
    this.word("declare");
    this.space();
  }
  this.word("function");
  this.space();
  this.print(node.id, node);
  this.print(node.id.typeAnnotation.typeAnnotation, node);
  if (node.predicate) {
    this.space();
    this.print(node.predicate, node);
  }
  this.semicolon();
 }
 function InferredPredicate() {
  this.token("%");
  this.word("checks");
 }
 function DeclaredPredicate(node) {
  this.token("%");
  this.word("checks");
  this.token("(");
  this.print(node.value, node);
  this.token(")");
 }
 function DeclareInterface(node) {
  this.word("declare");
  this.space();
  this.InterfaceDeclaration(node);
 }
 function DeclareModule(node) {
  this.word("declare");
  this.space();
  this.word("module");
  this.space();
  this.print(node.id, node);
  this.space();
  this.print(node.body, node);
 }
 function DeclareModuleExports(node) {
  this.word("declare");
  this.space();
  this.word("module");
  this.token(".");
  this.word("exports");
  this.print(node.typeAnnotation, node);
 }
 function DeclareTypeAlias(node) {
  this.word("declare");
  this.space();
  this.TypeAlias(node);
 }
 function DeclareOpaqueType(node, parent) {
  if (!t.isDeclareExportDeclaration(parent)) {
    this.word("declare");
    this.space();
  }
  this.OpaqueType(node);
 }
 function DeclareVariable(node, parent) {
  if (!t.isDeclareExportDeclaration(parent)) {
    this.word("declare");
    this.space();
  }
  this.word("var");
  this.space();
  this.print(node.id, node);
  this.print(node.id.typeAnnotation, node);
  this.semicolon();
 }
 function DeclareExportDeclaration(node) {
  this.word("declare");
  this.space();
  this.word("export");
  this.space();
  if (node.default) {
    this.word("default");
    this.space();
  }
  FlowExportDeclaration.apply(this, arguments);
 }
 function DeclareExportAllDeclaration() {
  this.word("declare");
  this.space();
  _modules.ExportAllDeclaration.apply(this, arguments);
 }
 function EnumDeclaration(node) {
  const {
    id,
    body
  } = node;
  this.word("enum");
  this.space();
  this.print(id, node);
  this.print(body, node);
 }
 function enumExplicitType(context, name, hasExplicitType) {
  if (hasExplicitType) {
    context.space();
    context.word("of");
    context.space();
    context.word(name);
  }
  context.space();
 }
 function enumBody(context, node) {
  const {
    members
  } = node;
  context.token("{");
  context.indent();
  context.newline();
  for (const member of members) {
    context.print(member, node);
    context.newline();
  }
  context.dedent();
  context.token("}");
 }
 function EnumBooleanBody(node) {
  const {
    explicitType
  } = node;
  enumExplicitType(this, "boolean", explicitType);
  enumBody(this, node);
 }
 function EnumNumberBody(node) {
  const {
    explicitType
  } = node;
  enumExplicitType(this, "number", explicitType);
  enumBody(this, node);
 }
 function EnumStringBody(node) {
  const {
    explicitType
  } = node;
  enumExplicitType(this, "string", explicitType);
  enumBody(this, node);
 }
 function EnumSymbolBody(node) {
  enumExplicitType(this, "symbol", true);
  enumBody(this, node);
 }
 function EnumDefaultedMember(node) {
  const {
    id
  } = node;
  this.print(id, node);
  this.token(",");
 }
 function enumInitializedMember(context, node) {
  const {
    id,
    init
  } = node;
  context.print(id, node);
  context.space();
  context.token("=");
  context.space();
  context.print(init, node);
  context.token(",");
 }
 function EnumBooleanMember(node) {
  enumInitializedMember(this, node);
 }
 function EnumNumberMember(node) {
  enumInitializedMember(this, node);
 }
 function EnumStringMember(node) {
  enumInitializedMember(this, node);
 }
 function FlowExportDeclaration(node) {
  if (node.declaration) {
    const declar = node.declaration;
    this.print(declar, node);
    if (!t.isStatement(declar)) this.semicolon();
  } else {
    this.token("{");
    if (node.specifiers.length) {
      this.space();
      this.printList(node.specifiers, node);
      this.space();
    }
    this.token("}");
    if (node.source) {
      this.space();
      this.word("from");
      this.space();
      this.print(node.source, node);
    }
    this.semicolon();
  }
 }
 function ExistsTypeAnnotation() {
  this.token("*");
 }
 function FunctionTypeAnnotation(node, parent) {
  this.print(node.typeParameters, node);
  this.token("(");
  this.printList(node.params, node);
  if (node.rest) {
    if (node.params.length) {
      this.token(",");
      this.space();
    }
    this.token("...");
    this.print(node.rest, node);
  }
  this.token(")");
  if (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method) {
    this.token(":");
  } else {
    this.space();
    this.token("=>");
  }
  this.space();
  this.print(node.returnType, node);
 }
 function FunctionTypeParam(node) {
  this.print(node.name, node);
  if (node.optional) this.token("?");
  if (node.name) {
    this.token(":");
    this.space();
  }
  this.print(node.typeAnnotation, node);
 }
 function InterfaceExtends(node) {
  this.print(node.id, node);
  this.print(node.typeParameters, node);
 }
 function _interfaceish(node) {
  this.print(node.id, node);
  this.print(node.typeParameters, node);
  if (node.extends.length) {
    this.space();
    this.word("extends");
    this.space();
    this.printList(node.extends, node);
  }
  if (node.mixins && node.mixins.length) {
    this.space();
    this.word("mixins");
    this.space();
    this.printList(node.mixins, node);
  }
  if (node.implements && node.implements.length) {
    this.space();
    this.word("implements");
    this.space();
    this.printList(node.implements, node);
  }
  this.space();
  this.print(node.body, node);
 }
 function _variance(node) {
  if (node.variance) {
    if (node.variance.kind === "plus") {
      this.token("+");
    } else if (node.variance.kind === "minus") {
      this.token("-");
    }
  }
 }
 function InterfaceDeclaration(node) {
  this.word("interface");
  this.space();
  this._interfaceish(node);
 }
 function andSeparator() {
  this.space();
  this.token("&");
  this.space();
 }
 function InterfaceTypeAnnotation(node) {
  this.word("interface");
  if (node.extends && node.extends.length) {
    this.space();
    this.word("extends");
    this.space();
    this.printList(node.extends, node);
  }
  this.space();
  this.print(node.body, node);
 }
 function IntersectionTypeAnnotation(node) {
  this.printJoin(node.types, node, {
    separator: andSeparator
  });
 }
 function MixedTypeAnnotation() {
  this.word("mixed");
 }
 function EmptyTypeAnnotation() {
  this.word("empty");
 }
 function NullableTypeAnnotation(node) {
  this.token("?");
  this.print(node.typeAnnotation, node);
 }
 function NumberTypeAnnotation() {
  this.word("number");
 }
 function StringTypeAnnotation() {
  this.word("string");
 }
 function ThisTypeAnnotation() {
  this.word("this");
 }
 function TupleTypeAnnotation(node) {
  this.token("[");
  this.printList(node.types, node);
  this.token("]");
 }
 function TypeofTypeAnnotation(node) {
  this.word("typeof");
  this.space();
  this.print(node.argument, node);
 }
 function TypeAlias(node) {
  this.word("type");
  this.space();
  this.print(node.id, node);
  this.print(node.typeParameters, node);
  this.space();
  this.token("=");
  this.space();
  this.print(node.right, node);
  this.semicolon();
 }
 function TypeAnnotation(node) {
  this.token(":");
  this.space();
  if (node.optional) this.token("?");
  this.print(node.typeAnnotation, node);
 }
 function TypeParameterInstantiation(node) {
  this.token("<");
  this.printList(node.params, node, {});
  this.token(">");
 }
 function TypeParameter(node) {
  this._variance(node);
  this.word(node.name);
  if (node.bound) {
    this.print(node.bound, node);
  }
  if (node.default) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.default, node);
  }
 }
 function OpaqueType(node) {
  this.word("opaque");
  this.space();
  this.word("type");
  this.space();
  this.print(node.id, node);
  this.print(node.typeParameters, node);
  if (node.supertype) {
    this.token(":");
    this.space();
    this.print(node.supertype, node);
  }
  if (node.impltype) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.impltype, node);
  }
  this.semicolon();
 }
 function ObjectTypeAnnotation(node) {
  if (node.exact) {
    this.token("{|");
  } else {
    this.token("{");
  }
  const props = node.properties.concat(node.callProperties || [], node.indexers || [], node.internalSlots || []);
  if (props.length) {
    this.space();
    this.printJoin(props, node, {
      addNewlines(leading) {
        if (leading && !props[0]) return 1;
      },
      indent: true,
      statement: true,
      iterator: () => {
        if (props.length !== 1 || node.inexact) {
          this.token(",");
          this.space();
        }
      }
    });
    this.space();
  }
  if (node.inexact) {
    this.indent();
    this.token("...");
    if (props.length) {
      this.newline();
    }
    this.dedent();
  }
  if (node.exact) {
    this.token("|}");
  } else {
    this.token("}");
  }
 }
 function ObjectTypeInternalSlot(node) {
  if (node.static) {
    this.word("static");
    this.space();
  }
  this.token("[");
  this.token("[");
  this.print(node.id, node);
  this.token("]");
  this.token("]");
  if (node.optional) this.token("?");
  if (!node.method) {
    this.token(":");
    this.space();
  }
  this.print(node.value, node);
 }
 function ObjectTypeCallProperty(node) {
  if (node.static) {
    this.word("static");
    this.space();
  }
  this.print(node.value, node);
 }
 function ObjectTypeIndexer(node) {
  if (node.static) {
    this.word("static");
    this.space();
  }
  this._variance(node);
  this.token("[");
  if (node.id) {
    this.print(node.id, node);
    this.token(":");
    this.space();
  }
  this.print(node.key, node);
  this.token("]");
  this.token(":");
  this.space();
  this.print(node.value, node);
 }
 function ObjectTypeProperty(node) {
  if (node.proto) {
    this.word("proto");
    this.space();
  }
  if (node.static) {
    this.word("static");
    this.space();
  }
  this._variance(node);
  this.print(node.key, node);
  if (node.optional) this.token("?");
  if (!node.method) {
    this.token(":");
    this.space();
  }
  this.print(node.value, node);
 }
 function ObjectTypeSpreadProperty(node) {
  this.token("...");
  this.print(node.argument, node);
 }
 function QualifiedTypeIdentifier(node) {
  this.print(node.qualification, node);
  this.token(".");
  this.print(node.id, node);
 }
 function SymbolTypeAnnotation() {
  this.word("symbol");
 }
 function orSeparator() {
  this.space();
  this.token("|");
  this.space();
 }
 function UnionTypeAnnotation(node) {
  this.printJoin(node.types, node, {
    separator: orSeparator
  });
 }
 function TypeCastExpression(node) {
  this.token("(");
  this.print(node.expression, node);
  this.print(node.typeAnnotation, node);
  this.token(")");
 }
 function Variance(node) {
  if (node.kind === "plus") {
    this.token("+");
  } else {
    this.token("-");
  }
 }
 function VoidTypeAnnotation() {
  this.word("void");
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/index.js
@ -0,0 +1,137 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 var _templateLiterals = require("./template-literals");
 Object.keys(_templateLiterals).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _templateLiterals[key];
    }
  });
 });
 var _expressions = require("./expressions");
 Object.keys(_expressions).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _expressions[key];
    }
  });
 });
 var _statements = require("./statements");
 Object.keys(_statements).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _statements[key];
    }
  });
 });
 var _classes = require("./classes");
 Object.keys(_classes).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _classes[key];
    }
  });
 });
 var _methods = require("./methods");
 Object.keys(_methods).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _methods[key];
    }
  });
 });
 var _modules = require("./modules");
 Object.keys(_modules).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _modules[key];
    }
  });
 });
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _types[key];
    }
  });
 });
 var _flow = require("./flow");
 Object.keys(_flow).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _flow[key];
    }
  });
 });
 var _base = require("./base");
 Object.keys(_base).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _base[key];
    }
  });
 });
 var _jsx = require("./jsx");
 Object.keys(_jsx).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _jsx[key];
    }
  });
 });
 var _typescript = require("./typescript");
 Object.keys(_typescript).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _typescript[key];
    }
  });
 });
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/jsx.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/jsx.js
@ -0,0 +1,145 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.JSXAttribute = JSXAttribute;
 exports.JSXIdentifier = JSXIdentifier;
 exports.JSXNamespacedName = JSXNamespacedName;
 exports.JSXMemberExpression = JSXMemberExpression;
 exports.JSXSpreadAttribute = JSXSpreadAttribute;
 exports.JSXExpressionContainer = JSXExpressionContainer;
 exports.JSXSpreadChild = JSXSpreadChild;
 exports.JSXText = JSXText;
 exports.JSXElement = JSXElement;
 exports.JSXOpeningElement = JSXOpeningElement;
 exports.JSXClosingElement = JSXClosingElement;
 exports.JSXEmptyExpression = JSXEmptyExpression;
 exports.JSXFragment = JSXFragment;
 exports.JSXOpeningFragment = JSXOpeningFragment;
 exports.JSXClosingFragment = JSXClosingFragment;
 function JSXAttribute(node) {
  this.print(node.name, node);
  if (node.value) {
    this.token("=");
    this.print(node.value, node);
  }
 }
 function JSXIdentifier(node) {
  this.word(node.name);
 }
 function JSXNamespacedName(node) {
  this.print(node.namespace, node);
  this.token(":");
  this.print(node.name, node);
 }
 function JSXMemberExpression(node) {
  this.print(node.object, node);
  this.token(".");
  this.print(node.property, node);
 }
 function JSXSpreadAttribute(node) {
  this.token("{");
  this.token("...");
  this.print(node.argument, node);
  this.token("}");
 }
 function JSXExpressionContainer(node) {
  this.token("{");
  this.print(node.expression, node);
  this.token("}");
 }
 function JSXSpreadChild(node) {
  this.token("{");
  this.token("...");
  this.print(node.expression, node);
  this.token("}");
 }
 function JSXText(node) {
  const raw = this.getPossibleRaw(node);
  if (raw != null) {
    this.token(raw);
  } else {
    this.token(node.value);
  }
 }
 function JSXElement(node) {
  const open = node.openingElement;
  this.print(open, node);
  if (open.selfClosing) return;
  this.indent();
  for (const child of node.children) {
    this.print(child, node);
  }
  this.dedent();
  this.print(node.closingElement, node);
 }
 function spaceSeparator() {
  this.space();
 }
 function JSXOpeningElement(node) {
  this.token("<");
  this.print(node.name, node);
  this.print(node.typeParameters, node);
  if (node.attributes.length > 0) {
    this.space();
    this.printJoin(node.attributes, node, {
      separator: spaceSeparator
    });
  }
  if (node.selfClosing) {
    this.space();
    this.token("/>");
  } else {
    this.token(">");
  }
 }
 function JSXClosingElement(node) {
  this.token("</");
  this.print(node.name, node);
  this.token(">");
 }
 function JSXEmptyExpression(node) {
  this.printInnerComments(node);
 }
 function JSXFragment(node) {
  this.print(node.openingFragment, node);
  this.indent();
  for (const child of node.children) {
    this.print(child, node);
  }
  this.dedent();
  this.print(node.closingFragment, node);
 }
 function JSXOpeningFragment() {
  this.token("<");
  this.token(">");
 }
 function JSXClosingFragment() {
  this.token("</");
  this.token(">");
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/methods.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/methods.js
@ -0,0 +1,161 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports._params = _params;
 exports._parameters = _parameters;
 exports._param = _param;
 exports._methodHead = _methodHead;
 exports._predicate = _predicate;
 exports._functionHead = _functionHead;
 exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _params(node) {
  this.print(node.typeParameters, node);
  this.token("(");
  this._parameters(node.params, node);
  this.token(")");
  this.print(node.returnType, node);
 }
 function _parameters(parameters, parent) {
  for (let i = 0; i < parameters.length; i++) {
    this._param(parameters[i], parent);
    if (i < parameters.length - 1) {
      this.token(",");
      this.space();
    }
  }
 }
 function _param(parameter, parent) {
  this.printJoin(parameter.decorators, parameter);
  this.print(parameter, parent);
  if (parameter.optional) this.token("?");
  this.print(parameter.typeAnnotation, parameter);
 }
 function _methodHead(node) {
  const kind = node.kind;
  const key = node.key;
  if (kind === "get" || kind === "set") {
    this.word(kind);
    this.space();
  }
  if (node.async) {
    this.word("async");
    this.space();
  }
  if (kind === "method" || kind === "init") {
    if (node.generator) {
      this.token("*");
    }
  }
  if (node.computed) {
    this.token("[");
    this.print(key, node);
    this.token("]");
  } else {
    this.print(key, node);
  }
  if (node.optional) {
    this.token("?");
  }
  this._params(node);
 }
 function _predicate(node) {
  if (node.predicate) {
    if (!node.returnType) {
      this.token(":");
    }
    this.space();
    this.print(node.predicate, node);
  }
 }
 function _functionHead(node) {
  if (node.async) {
    this.word("async");
    this.space();
  }
  this.word("function");
  if (node.generator) this.token("*");
  this.space();
  if (node.id) {
    this.print(node.id, node);
  }
  this._params(node);
  this._predicate(node);
 }
 function FunctionExpression(node) {
  this._functionHead(node);
  this.space();
  this.print(node.body, node);
 }
 function ArrowFunctionExpression(node) {
  if (node.async) {
    this.word("async");
    this.space();
  }
  const firstParam = node.params[0];
  if (node.params.length === 1 && t.isIdentifier(firstParam) && !hasTypes(node, firstParam)) {
    if (this.format.retainLines && node.loc && node.body.loc && node.loc.start.line < node.body.loc.start.line) {
      this.token("(");
      if (firstParam.loc && firstParam.loc.start.line > node.loc.start.line) {
        this.indent();
        this.print(firstParam, node);
        this.dedent();
        this._catchUp("start", node.body.loc);
      } else {
        this.print(firstParam, node);
      }
      this.token(")");
    } else {
      this.print(firstParam, node);
    }
  } else {
    this._params(node);
  }
  this._predicate(node);
  this.space();
  this.token("=>");
  this.space();
  this.print(node.body, node);
 }
 function hasTypes(node, param) {
  return node.typeParameters || node.returnType || param.typeAnnotation || param.optional || param.trailingComments;
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/modules.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/modules.js
@ -0,0 +1,208 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.ImportSpecifier = ImportSpecifier;
 exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
 exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
 exports.ExportSpecifier = ExportSpecifier;
 exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
 exports.ExportAllDeclaration = ExportAllDeclaration;
 exports.ExportNamedDeclaration = ExportNamedDeclaration;
 exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
 exports.ImportDeclaration = ImportDeclaration;
 exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function ImportSpecifier(node) {
  if (node.importKind === "type" || node.importKind === "typeof") {
    this.word(node.importKind);
    this.space();
  }
  this.print(node.imported, node);
  if (node.local && node.local.name !== node.imported.name) {
    this.space();
    this.word("as");
    this.space();
    this.print(node.local, node);
  }
 }
 function ImportDefaultSpecifier(node) {
  this.print(node.local, node);
 }
 function ExportDefaultSpecifier(node) {
  this.print(node.exported, node);
 }
 function ExportSpecifier(node) {
  this.print(node.local, node);
  if (node.exported && node.local.name !== node.exported.name) {
    this.space();
    this.word("as");
    this.space();
    this.print(node.exported, node);
  }
 }
 function ExportNamespaceSpecifier(node) {
  this.token("*");
  this.space();
  this.word("as");
  this.space();
  this.print(node.exported, node);
 }
 function ExportAllDeclaration(node) {
  this.word("export");
  this.space();
  if (node.exportKind === "type") {
    this.word("type");
    this.space();
  }
  this.token("*");
  this.space();
  this.word("from");
  this.space();
  this.print(node.source, node);
  this.semicolon();
 }
 function ExportNamedDeclaration(node) {
  if (this.format.decoratorsBeforeExport && t.isClassDeclaration(node.declaration)) {
    this.printJoin(node.declaration.decorators, node);
  }
  this.word("export");
  this.space();
  ExportDeclaration.apply(this, arguments);
 }
 function ExportDefaultDeclaration(node) {
  if (this.format.decoratorsBeforeExport && t.isClassDeclaration(node.declaration)) {
    this.printJoin(node.declaration.decorators, node);
  }
  this.word("export");
  this.space();
  this.word("default");
  this.space();
  ExportDeclaration.apply(this, arguments);
 }
 function ExportDeclaration(node) {
  if (node.declaration) {
    const declar = node.declaration;
    this.print(declar, node);
    if (!t.isStatement(declar)) this.semicolon();
  } else {
    if (node.exportKind === "type") {
      this.word("type");
      this.space();
    }
    const specifiers = node.specifiers.slice(0);
    let hasSpecial = false;
    for (;;) {
      const first = specifiers[0];
      if (t.isExportDefaultSpecifier(first) || t.isExportNamespaceSpecifier(first)) {
        hasSpecial = true;
        this.print(specifiers.shift(), node);
        if (specifiers.length) {
          this.token(",");
          this.space();
        }
      } else {
        break;
      }
    }
    if (specifiers.length || !specifiers.length && !hasSpecial) {
      this.token("{");
      if (specifiers.length) {
        this.space();
        this.printList(specifiers, node);
        this.space();
      }
      this.token("}");
    }
    if (node.source) {
      this.space();
      this.word("from");
      this.space();
      this.print(node.source, node);
    }
    this.semicolon();
  }
 }
 function ImportDeclaration(node) {
  this.word("import");
  this.space();
  if (node.importKind === "type" || node.importKind === "typeof") {
    this.word(node.importKind);
    this.space();
  }
  const specifiers = node.specifiers.slice(0);
  if (specifiers && specifiers.length) {
    for (;;) {
      const first = specifiers[0];
      if (t.isImportDefaultSpecifier(first) || t.isImportNamespaceSpecifier(first)) {
        this.print(specifiers.shift(), node);
        if (specifiers.length) {
          this.token(",");
          this.space();
        }
      } else {
        break;
      }
    }
    if (specifiers.length) {
      this.token("{");
      this.space();
      this.printList(specifiers, node);
      this.space();
      this.token("}");
    }
    this.space();
    this.word("from");
    this.space();
  }
  this.print(node.source, node);
  this.semicolon();
 }
 function ImportNamespaceSpecifier(node) {
  this.token("*");
  this.space();
  this.word("as");
  this.space();
  this.print(node.local, node);
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/statements.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/statements.js
@ -0,0 +1,313 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.WithStatement = WithStatement;
 exports.IfStatement = IfStatement;
 exports.ForStatement = ForStatement;
 exports.WhileStatement = WhileStatement;
 exports.DoWhileStatement = DoWhileStatement;
 exports.LabeledStatement = LabeledStatement;
 exports.TryStatement = TryStatement;
 exports.CatchClause = CatchClause;
 exports.SwitchStatement = SwitchStatement;
 exports.SwitchCase = SwitchCase;
 exports.DebuggerStatement = DebuggerStatement;
 exports.VariableDeclaration = VariableDeclaration;
 exports.VariableDeclarator = VariableDeclarator;
 exports.ThrowStatement = exports.BreakStatement = exports.ReturnStatement = exports.ContinueStatement = exports.ForOfStatement = exports.ForInStatement = void 0;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function WithStatement(node) {
  this.word("with");
  this.space();
  this.token("(");
  this.print(node.object, node);
  this.token(")");
  this.printBlock(node);
 }
 function IfStatement(node) {
  this.word("if");
  this.space();
  this.token("(");
  this.print(node.test, node);
  this.token(")");
  this.space();
  const needsBlock = node.alternate && t.isIfStatement(getLastStatement(node.consequent));
  if (needsBlock) {
    this.token("{");
    this.newline();
    this.indent();
  }
  this.printAndIndentOnComments(node.consequent, node);
  if (needsBlock) {
    this.dedent();
    this.newline();
    this.token("}");
  }
  if (node.alternate) {
    if (this.endsWith("}")) this.space();
    this.word("else");
    this.space();
    this.printAndIndentOnComments(node.alternate, node);
  }
 }
 function getLastStatement(statement) {
  if (!t.isStatement(statement.body)) return statement;
  return getLastStatement(statement.body);
 }
 function ForStatement(node) {
  this.word("for");
  this.space();
  this.token("(");
  this.inForStatementInitCounter++;
  this.print(node.init, node);
  this.inForStatementInitCounter--;
  this.token(";");
  if (node.test) {
    this.space();
    this.print(node.test, node);
  }
  this.token(";");
  if (node.update) {
    this.space();
    this.print(node.update, node);
  }
  this.token(")");
  this.printBlock(node);
 }
 function WhileStatement(node) {
  this.word("while");
  this.space();
  this.token("(");
  this.print(node.test, node);
  this.token(")");
  this.printBlock(node);
 }
 const buildForXStatement = function (op) {
  return function (node) {
    this.word("for");
    this.space();
    if (op === "of" && node.await) {
      this.word("await");
      this.space();
    }
    this.token("(");
    this.print(node.left, node);
    this.space();
    this.word(op);
    this.space();
    this.print(node.right, node);
    this.token(")");
    this.printBlock(node);
  };
 };
 const ForInStatement = buildForXStatement("in");
 exports.ForInStatement = ForInStatement;
 const ForOfStatement = buildForXStatement("of");
 exports.ForOfStatement = ForOfStatement;
 function DoWhileStatement(node) {
  this.word("do");
  this.space();
  this.print(node.body, node);
  this.space();
  this.word("while");
  this.space();
  this.token("(");
  this.print(node.test, node);
  this.token(")");
  this.semicolon();
 }
 function buildLabelStatement(prefix, key = "label") {
  return function (node) {
    this.word(prefix);
    const label = node[key];
    if (label) {
      this.space();
      const isLabel = key == "label";
      const terminatorState = this.startTerminatorless(isLabel);
      this.print(label, node);
      this.endTerminatorless(terminatorState);
    }
    this.semicolon();
  };
 }
 const ContinueStatement = buildLabelStatement("continue");
 exports.ContinueStatement = ContinueStatement;
 const ReturnStatement = buildLabelStatement("return", "argument");
 exports.ReturnStatement = ReturnStatement;
 const BreakStatement = buildLabelStatement("break");
 exports.BreakStatement = BreakStatement;
 const ThrowStatement = buildLabelStatement("throw", "argument");
 exports.ThrowStatement = ThrowStatement;
 function LabeledStatement(node) {
  this.print(node.label, node);
  this.token(":");
  this.space();
  this.print(node.body, node);
 }
 function TryStatement(node) {
  this.word("try");
  this.space();
  this.print(node.block, node);
  this.space();
  if (node.handlers) {
    this.print(node.handlers[0], node);
  } else {
    this.print(node.handler, node);
  }
  if (node.finalizer) {
    this.space();
    this.word("finally");
    this.space();
    this.print(node.finalizer, node);
  }
 }
 function CatchClause(node) {
  this.word("catch");
  this.space();
  if (node.param) {
    this.token("(");
    this.print(node.param, node);
    this.token(")");
    this.space();
  }
  this.print(node.body, node);
 }
 function SwitchStatement(node) {
  this.word("switch");
  this.space();
  this.token("(");
  this.print(node.discriminant, node);
  this.token(")");
  this.space();
  this.token("{");
  this.printSequence(node.cases, node, {
    indent: true,
    addNewlines(leading, cas) {
      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
    }
  });
  this.token("}");
 }
 function SwitchCase(node) {
  if (node.test) {
    this.word("case");
    this.space();
    this.print(node.test, node);
    this.token(":");
  } else {
    this.word("default");
    this.token(":");
  }
  if (node.consequent.length) {
    this.newline();
    this.printSequence(node.consequent, node, {
      indent: true
    });
  }
 }
 function DebuggerStatement() {
  this.word("debugger");
  this.semicolon();
 }
 function variableDeclarationIndent() {
  this.token(",");
  this.newline();
  if (this.endsWith("\n")) for (let i = 0; i < 4; i++) this.space(true);
 }
 function constDeclarationIndent() {
  this.token(",");
  this.newline();
  if (this.endsWith("\n")) for (let i = 0; i < 6; i++) this.space(true);
 }
 function VariableDeclaration(node, parent) {
  if (node.declare) {
    this.word("declare");
    this.space();
  }
  this.word(node.kind);
  this.space();
  let hasInits = false;
  if (!t.isFor(parent)) {
    for (const declar of node.declarations) {
      if (declar.init) {
        hasInits = true;
      }
    }
  }
  let separator;
  if (hasInits) {
    separator = node.kind === "const" ? constDeclarationIndent : variableDeclarationIndent;
  }
  this.printList(node.declarations, node, {
    separator
  });
  if (t.isFor(parent)) {
    if (parent.left === node || parent.init === node) return;
  }
  this.semicolon();
 }
 function VariableDeclarator(node) {
  this.print(node.id, node);
  if (node.definite) this.token("!");
  this.print(node.id.typeAnnotation, node);
  if (node.init) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.init, node);
  }
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/template-literals.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/template-literals.js
@ -0,0 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 exports.TemplateElement = TemplateElement;
 exports.TemplateLiteral = TemplateLiteral;
 function TaggedTemplateExpression(node) {
  this.print(node.tag, node);
  this.print(node.typeParameters, node);
  this.print(node.quasi, node);
 }
 function TemplateElement(node, parent) {
  const isFirst = parent.quasis[0] === node;
  const isLast = parent.quasis[parent.quasis.length - 1] === node;
  const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${");
  this.token(value);
 }
 function TemplateLiteral(node) {
  const quasis = node.quasis;
  for (let i = 0; i < quasis.length; i++) {
    this.print(quasis[i], node);
    if (i + 1 < quasis.length) {
      this.print(node.expressions[i], node);
    }
  }
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/types.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/types.js
@ -0,0 +1,251 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.Identifier = Identifier;
 exports.ArgumentPlaceholder = ArgumentPlaceholder;
 exports.SpreadElement = exports.RestElement = RestElement;
 exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
 exports.ObjectMethod = ObjectMethod;
 exports.ObjectProperty = ObjectProperty;
 exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
 exports.RecordExpression = RecordExpression;
 exports.TupleExpression = TupleExpression;
 exports.RegExpLiteral = RegExpLiteral;
 exports.BooleanLiteral = BooleanLiteral;
 exports.NullLiteral = NullLiteral;
 exports.NumericLiteral = NumericLiteral;
 exports.StringLiteral = StringLiteral;
 exports.BigIntLiteral = BigIntLiteral;
 exports.PipelineTopicExpression = PipelineTopicExpression;
 exports.PipelineBareFunction = PipelineBareFunction;
 exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
 var t = _interopRequireWildcard(require("@babel/types"));
 var _jsesc = _interopRequireDefault(require("jsesc"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function Identifier(node) {
  this.exactSource(node.loc, () => {
    this.word(node.name);
  });
 }
 function ArgumentPlaceholder() {
  this.token("?");
 }
 function RestElement(node) {
  this.token("...");
  this.print(node.argument, node);
 }
 function ObjectExpression(node) {
  const props = node.properties;
  this.token("{");
  this.printInnerComments(node);
  if (props.length) {
    this.space();
    this.printList(props, node, {
      indent: true,
      statement: true
    });
    this.space();
  }
  this.token("}");
 }
 function ObjectMethod(node) {
  this.printJoin(node.decorators, node);
  this._methodHead(node);
  this.space();
  this.print(node.body, node);
 }
 function ObjectProperty(node) {
  this.printJoin(node.decorators, node);
  if (node.computed) {
    this.token("[");
    this.print(node.key, node);
    this.token("]");
  } else {
    if (t.isAssignmentPattern(node.value) && t.isIdentifier(node.key) && node.key.name === node.value.left.name) {
      this.print(node.value, node);
      return;
    }
    this.print(node.key, node);
    if (node.shorthand && t.isIdentifier(node.key) && t.isIdentifier(node.value) && node.key.name === node.value.name) {
      return;
    }
  }
  this.token(":");
  this.space();
  this.print(node.value, node);
 }
 function ArrayExpression(node) {
  const elems = node.elements;
  const len = elems.length;
  this.token("[");
  this.printInnerComments(node);
  for (let i = 0; i < elems.length; i++) {
    const elem = elems[i];
    if (elem) {
      if (i > 0) this.space();
      this.print(elem, node);
      if (i < len - 1) this.token(",");
    } else {
      this.token(",");
    }
  }
  this.token("]");
 }
 function RecordExpression(node) {
  const props = node.properties;
  let startToken;
  let endToken;
  if (this.format.recordAndTupleSyntaxType === "bar") {
    startToken = "{|";
    endToken = "|}";
  } else if (this.format.recordAndTupleSyntaxType === "hash") {
    startToken = "#{";
    endToken = "}";
  } else {
    throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
  }
  this.token(startToken);
  this.printInnerComments(node);
  if (props.length) {
    this.space();
    this.printList(props, node, {
      indent: true,
      statement: true
    });
    this.space();
  }
  this.token(endToken);
 }
 function TupleExpression(node) {
  const elems = node.elements;
  const len = elems.length;
  let startToken;
  let endToken;
  if (this.format.recordAndTupleSyntaxType === "bar") {
    startToken = "[|";
    endToken = "|]";
  } else if (this.format.recordAndTupleSyntaxType === "hash") {
    startToken = "#[";
    endToken = "]";
  } else {
    throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
  }
  this.token(startToken);
  this.printInnerComments(node);
  for (let i = 0; i < elems.length; i++) {
    const elem = elems[i];
    if (elem) {
      if (i > 0) this.space();
      this.print(elem, node);
      if (i < len - 1) this.token(",");
    }
  }
  this.token(endToken);
 }
 function RegExpLiteral(node) {
  this.word(`/${node.pattern}/${node.flags}`);
 }
 function BooleanLiteral(node) {
  this.word(node.value ? "true" : "false");
 }
 function NullLiteral() {
  this.word("null");
 }
 function NumericLiteral(node) {
  const raw = this.getPossibleRaw(node);
  const opts = this.format.jsescOption;
  const value = node.value + "";
  if (opts.numbers) {
    this.number((0, _jsesc.default)(node.value, opts));
  } else if (raw == null) {
    this.number(value);
  } else if (this.format.minified) {
    this.number(raw.length < value.length ? raw : value);
  } else {
    this.number(raw);
  }
 }
 function StringLiteral(node) {
  const raw = this.getPossibleRaw(node);
  if (!this.format.minified && raw != null) {
    this.token(raw);
    return;
  }
  const opts = this.format.jsescOption;
  if (this.format.jsonCompatibleStrings) {
    opts.json = true;
  }
  const val = (0, _jsesc.default)(node.value, opts);
  return this.token(val);
 }
 function BigIntLiteral(node) {
  const raw = this.getPossibleRaw(node);
  if (!this.format.minified && raw != null) {
    this.token(raw);
    return;
  }
  this.token(node.value);
 }
 function PipelineTopicExpression(node) {
  this.print(node.expression, node);
 }
 function PipelineBareFunction(node) {
  this.print(node.callee, node);
 }
 function PipelinePrimaryTopicReference() {
  this.token("#");
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/typescript.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/generators/typescript.js
@ -0,0 +1,758 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.TSTypeAnnotation = TSTypeAnnotation;
 exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
 exports.TSTypeParameter = TSTypeParameter;
 exports.TSParameterProperty = TSParameterProperty;
 exports.TSDeclareFunction = TSDeclareFunction;
 exports.TSDeclareMethod = TSDeclareMethod;
 exports.TSQualifiedName = TSQualifiedName;
 exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
 exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
 exports.TSPropertySignature = TSPropertySignature;
 exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
 exports.TSMethodSignature = TSMethodSignature;
 exports.TSIndexSignature = TSIndexSignature;
 exports.TSAnyKeyword = TSAnyKeyword;
 exports.TSBigIntKeyword = TSBigIntKeyword;
 exports.TSUnknownKeyword = TSUnknownKeyword;
 exports.TSNumberKeyword = TSNumberKeyword;
 exports.TSObjectKeyword = TSObjectKeyword;
 exports.TSBooleanKeyword = TSBooleanKeyword;
 exports.TSStringKeyword = TSStringKeyword;
 exports.TSSymbolKeyword = TSSymbolKeyword;
 exports.TSVoidKeyword = TSVoidKeyword;
 exports.TSUndefinedKeyword = TSUndefinedKeyword;
 exports.TSNullKeyword = TSNullKeyword;
 exports.TSNeverKeyword = TSNeverKeyword;
 exports.TSThisType = TSThisType;
 exports.TSFunctionType = TSFunctionType;
 exports.TSConstructorType = TSConstructorType;
 exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
 exports.TSTypeReference = TSTypeReference;
 exports.TSTypePredicate = TSTypePredicate;
 exports.TSTypeQuery = TSTypeQuery;
 exports.TSTypeLiteral = TSTypeLiteral;
 exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
 exports.tsPrintBraced = tsPrintBraced;
 exports.TSArrayType = TSArrayType;
 exports.TSTupleType = TSTupleType;
 exports.TSOptionalType = TSOptionalType;
 exports.TSRestType = TSRestType;
 exports.TSUnionType = TSUnionType;
 exports.TSIntersectionType = TSIntersectionType;
 exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
 exports.TSConditionalType = TSConditionalType;
 exports.TSInferType = TSInferType;
 exports.TSParenthesizedType = TSParenthesizedType;
 exports.TSTypeOperator = TSTypeOperator;
 exports.TSIndexedAccessType = TSIndexedAccessType;
 exports.TSMappedType = TSMappedType;
 exports.TSLiteralType = TSLiteralType;
 exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
 exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
 exports.TSInterfaceBody = TSInterfaceBody;
 exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
 exports.TSAsExpression = TSAsExpression;
 exports.TSTypeAssertion = TSTypeAssertion;
 exports.TSEnumDeclaration = TSEnumDeclaration;
 exports.TSEnumMember = TSEnumMember;
 exports.TSModuleDeclaration = TSModuleDeclaration;
 exports.TSModuleBlock = TSModuleBlock;
 exports.TSImportType = TSImportType;
 exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
 exports.TSExternalModuleReference = TSExternalModuleReference;
 exports.TSNonNullExpression = TSNonNullExpression;
 exports.TSExportAssignment = TSExportAssignment;
 exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
 exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
 exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
 function TSTypeAnnotation(node) {
  this.token(":");
  this.space();
  if (node.optional) this.token("?");
  this.print(node.typeAnnotation, node);
 }
 function TSTypeParameterInstantiation(node) {
  this.token("<");
  this.printList(node.params, node, {});
  this.token(">");
 }
 function TSTypeParameter(node) {
  this.word(node.name);
  if (node.constraint) {
    this.space();
    this.word("extends");
    this.space();
    this.print(node.constraint, node);
  }
  if (node.default) {
    this.space();
    this.token("=");
    this.space();
    this.print(node.default, node);
  }
 }
 function TSParameterProperty(node) {
  if (node.accessibility) {
    this.word(node.accessibility);
    this.space();
  }
  if (node.readonly) {
    this.word("readonly");
    this.space();
  }
  this._param(node.parameter);
 }
 function TSDeclareFunction(node) {
  if (node.declare) {
    this.word("declare");
    this.space();
  }
  this._functionHead(node);
  this.token(";");
 }
 function TSDeclareMethod(node) {
  this._classMethodHead(node);
  this.token(";");
 }
 function TSQualifiedName(node) {
  this.print(node.left, node);
  this.token(".");
  this.print(node.right, node);
 }
 function TSCallSignatureDeclaration(node) {
  this.tsPrintSignatureDeclarationBase(node);
  this.token(";");
 }
 function TSConstructSignatureDeclaration(node) {
  this.word("new");
  this.space();
  this.tsPrintSignatureDeclarationBase(node);
  this.token(";");
 }
 function TSPropertySignature(node) {
  const {
    readonly,
    initializer
  } = node;
  if (readonly) {
    this.word("readonly");
    this.space();
  }
  this.tsPrintPropertyOrMethodName(node);
  this.print(node.typeAnnotation, node);
  if (initializer) {
    this.space();
    this.token("=");
    this.space();
    this.print(initializer, node);
  }
  this.token(";");
 }
 function tsPrintPropertyOrMethodName(node) {
  if (node.computed) {
    this.token("[");
  }
  this.print(node.key, node);
  if (node.computed) {
    this.token("]");
  }
  if (node.optional) {
    this.token("?");
  }
 }
 function TSMethodSignature(node) {
  this.tsPrintPropertyOrMethodName(node);
  this.tsPrintSignatureDeclarationBase(node);
  this.token(";");
 }
 function TSIndexSignature(node) {
  const {
    readonly
  } = node;
  if (readonly) {
    this.word("readonly");
    this.space();
  }
  this.token("[");
  this._parameters(node.parameters, node);
  this.token("]");
  this.print(node.typeAnnotation, node);
  this.token(";");
 }
 function TSAnyKeyword() {
  this.word("any");
 }
 function TSBigIntKeyword() {
  this.word("bigint");
 }
 function TSUnknownKeyword() {
  this.word("unknown");
 }
 function TSNumberKeyword() {
  this.word("number");
 }
 function TSObjectKeyword() {
  this.word("object");
 }
 function TSBooleanKeyword() {
  this.word("boolean");
 }
 function TSStringKeyword() {
  this.word("string");
 }
 function TSSymbolKeyword() {
  this.word("symbol");
 }
 function TSVoidKeyword() {
  this.word("void");
 }
 function TSUndefinedKeyword() {
  this.word("undefined");
 }
 function TSNullKeyword() {
  this.word("null");
 }
 function TSNeverKeyword() {
  this.word("never");
 }
 function TSThisType() {
  this.word("this");
 }
 function TSFunctionType(node) {
  this.tsPrintFunctionOrConstructorType(node);
 }
 function TSConstructorType(node) {
  this.word("new");
  this.space();
  this.tsPrintFunctionOrConstructorType(node);
 }
 function tsPrintFunctionOrConstructorType(node) {
  const {
    typeParameters,
    parameters
  } = node;
  this.print(typeParameters, node);
  this.token("(");
  this._parameters(parameters, node);
  this.token(")");
  this.space();
  this.token("=>");
  this.space();
  this.print(node.typeAnnotation.typeAnnotation, node);
 }
 function TSTypeReference(node) {
  this.print(node.typeName, node);
  this.print(node.typeParameters, node);
 }
 function TSTypePredicate(node) {
  if (node.asserts) {
    this.word("asserts");
    this.space();
  }
  this.print(node.parameterName);
  if (node.typeAnnotation) {
    this.space();
    this.word("is");
    this.space();
    this.print(node.typeAnnotation.typeAnnotation);
  }
 }
 function TSTypeQuery(node) {
  this.word("typeof");
  this.space();
  this.print(node.exprName);
 }
 function TSTypeLiteral(node) {
  this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
 }
 function tsPrintTypeLiteralOrInterfaceBody(members, node) {
  this.tsPrintBraced(members, node);
 }
 function tsPrintBraced(members, node) {
  this.token("{");
  if (members.length) {
    this.indent();
    this.newline();
    for (const member of members) {
      this.print(member, node);
      this.newline();
    }
    this.dedent();
    this.rightBrace();
  } else {
    this.token("}");
  }
 }
 function TSArrayType(node) {
  this.print(node.elementType, node);
  this.token("[]");
 }
 function TSTupleType(node) {
  this.token("[");
  this.printList(node.elementTypes, node);
  this.token("]");
 }
 function TSOptionalType(node) {
  this.print(node.typeAnnotation, node);
  this.token("?");
 }
 function TSRestType(node) {
  this.token("...");
  this.print(node.typeAnnotation, node);
 }
 function TSUnionType(node) {
  this.tsPrintUnionOrIntersectionType(node, "|");
 }
 function TSIntersectionType(node) {
  this.tsPrintUnionOrIntersectionType(node, "&");
 }
 function tsPrintUnionOrIntersectionType(node, sep) {
  this.printJoin(node.types, node, {
    separator() {
      this.space();
      this.token(sep);
      this.space();
    }
  });
 }
 function TSConditionalType(node) {
  this.print(node.checkType);
  this.space();
  this.word("extends");
  this.space();
  this.print(node.extendsType);
  this.space();
  this.token("?");
  this.space();
  this.print(node.trueType);
  this.space();
  this.token(":");
  this.space();
  this.print(node.falseType);
 }
 function TSInferType(node) {
  this.token("infer");
  this.space();
  this.print(node.typeParameter);
 }
 function TSParenthesizedType(node) {
  this.token("(");
  this.print(node.typeAnnotation, node);
  this.token(")");
 }
 function TSTypeOperator(node) {
  this.token(node.operator);
  this.space();
  this.print(node.typeAnnotation, node);
 }
 function TSIndexedAccessType(node) {
  this.print(node.objectType, node);
  this.token("[");
  this.print(node.indexType, node);
  this.token("]");
 }
 function TSMappedType(node) {
  const {
    readonly,
    typeParameter,
    optional
  } = node;
  this.token("{");
  this.space();
  if (readonly) {
    tokenIfPlusMinus(this, readonly);
    this.word("readonly");
    this.space();
  }
  this.token("[");
  this.word(typeParameter.name);
  this.space();
  this.word("in");
  this.space();
  this.print(typeParameter.constraint, typeParameter);
  this.token("]");
  if (optional) {
    tokenIfPlusMinus(this, optional);
    this.token("?");
  }
  this.token(":");
  this.space();
  this.print(node.typeAnnotation, node);
  this.space();
  this.token("}");
 }
 function tokenIfPlusMinus(self, tok) {
  if (tok !== true) {
    self.token(tok);
  }
 }
 function TSLiteralType(node) {
  this.print(node.literal, node);
 }
 function TSExpressionWithTypeArguments(node) {
  this.print(node.expression, node);
  this.print(node.typeParameters, node);
 }
 function TSInterfaceDeclaration(node) {
  const {
    declare,
    id,
    typeParameters,
    extends: extendz,
    body
  } = node;
  if (declare) {
    this.word("declare");
    this.space();
  }
  this.word("interface");
  this.space();
  this.print(id, node);
  this.print(typeParameters, node);
  if (extendz) {
    this.space();
    this.word("extends");
    this.space();
    this.printList(extendz, node);
  }
  this.space();
  this.print(body, node);
 }
 function TSInterfaceBody(node) {
  this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
 }
 function TSTypeAliasDeclaration(node) {
  const {
    declare,
    id,
    typeParameters,
    typeAnnotation
  } = node;
  if (declare) {
    this.word("declare");
    this.space();
  }
  this.word("type");
  this.space();
  this.print(id, node);
  this.print(typeParameters, node);
  this.space();
  this.token("=");
  this.space();
  this.print(typeAnnotation, node);
  this.token(";");
 }
 function TSAsExpression(node) {
  const {
    expression,
    typeAnnotation
  } = node;
  this.print(expression, node);
  this.space();
  this.word("as");
  this.space();
  this.print(typeAnnotation, node);
 }
 function TSTypeAssertion(node) {
  const {
    typeAnnotation,
    expression
  } = node;
  this.token("<");
  this.print(typeAnnotation, node);
  this.token(">");
  this.space();
  this.print(expression, node);
 }
 function TSEnumDeclaration(node) {
  const {
    declare,
    const: isConst,
    id,
    members
  } = node;
  if (declare) {
    this.word("declare");
    this.space();
  }
  if (isConst) {
    this.word("const");
    this.space();
  }
  this.word("enum");
  this.space();
  this.print(id, node);
  this.space();
  this.tsPrintBraced(members, node);
 }
 function TSEnumMember(node) {
  const {
    id,
    initializer
  } = node;
  this.print(id, node);
  if (initializer) {
    this.space();
    this.token("=");
    this.space();
    this.print(initializer, node);
  }
  this.token(",");
 }
 function TSModuleDeclaration(node) {
  const {
    declare,
    id
  } = node;
  if (declare) {
    this.word("declare");
    this.space();
  }
  if (!node.global) {
    this.word(id.type === "Identifier" ? "namespace" : "module");
    this.space();
  }
  this.print(id, node);
  if (!node.body) {
    this.token(";");
    return;
  }
  let body = node.body;
  while (body.type === "TSModuleDeclaration") {
    this.token(".");
    this.print(body.id, body);
    body = body.body;
  }
  this.space();
  this.print(body, node);
 }
 function TSModuleBlock(node) {
  this.tsPrintBraced(node.body, node);
 }
 function TSImportType(node) {
  const {
    argument,
    qualifier,
    typeParameters
  } = node;
  this.word("import");
  this.token("(");
  this.print(argument, node);
  this.token(")");
  if (qualifier) {
    this.token(".");
    this.print(qualifier, node);
  }
  if (typeParameters) {
    this.print(typeParameters, node);
  }
 }
 function TSImportEqualsDeclaration(node) {
  const {
    isExport,
    id,
    moduleReference
  } = node;
  if (isExport) {
    this.word("export");
    this.space();
  }
  this.word("import");
  this.space();
  this.print(id, node);
  this.space();
  this.token("=");
  this.space();
  this.print(moduleReference, node);
  this.token(";");
 }
 function TSExternalModuleReference(node) {
  this.token("require(");
  this.print(node.expression, node);
  this.token(")");
 }
 function TSNonNullExpression(node) {
  this.print(node.expression, node);
  this.token("!");
 }
 function TSExportAssignment(node) {
  this.word("export");
  this.space();
  this.token("=");
  this.space();
  this.print(node.expression, node);
  this.token(";");
 }
 function TSNamespaceExportDeclaration(node) {
  this.word("export");
  this.space();
  this.word("as");
  this.space();
  this.word("namespace");
  this.space();
  this.print(node.id, node);
 }
 function tsPrintSignatureDeclarationBase(node) {
  const {
    typeParameters,
    parameters
  } = node;
  this.print(typeParameters, node);
  this.token("(");
  this._parameters(parameters, node);
  this.token(")");
  this.print(node.typeAnnotation, node);
 }
 function tsPrintClassMemberModifiers(node, isField) {
  if (isField && node.declare) {
    this.word("declare");
    this.space();
  }
  if (node.accessibility) {
    this.word(node.accessibility);
    this.space();
  }
  if (node.static) {
    this.word("static");
    this.space();
  }
  if (node.abstract) {
    this.word("abstract");
    this.space();
  }
  if (isField && node.readonly) {
    this.word("readonly");
    this.space();
  }
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/index.js
@ -0,0 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = _default;
 exports.CodeGenerator = void 0;
 var _sourceMap = _interopRequireDefault(require("./source-map"));
 var _printer = _interopRequireDefault(require("./printer"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class Generator extends _printer.default {
  constructor(ast, opts = {}, code) {
    const format = normalizeOptions(code, opts);
    const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
    super(format, map);
    this.ast = ast;
  }
  generate() {
    return super.generate(this.ast);
  }
 }
 function normalizeOptions(code, opts) {
  const format = {
    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
    shouldPrintComment: opts.shouldPrintComment,
    retainLines: opts.retainLines,
    retainFunctionParens: opts.retainFunctionParens,
    comments: opts.comments == null || opts.comments,
    compact: opts.compact,
    minified: opts.minified,
    concise: opts.concise,
    jsonCompatibleStrings: opts.jsonCompatibleStrings,
    indent: {
      adjustMultilineComment: true,
      style: "  ",
      base: 0
    },
    decoratorsBeforeExport: !!opts.decoratorsBeforeExport,
    jsescOption: Object.assign({
      quotes: "double",
      wrap: true
    }, opts.jsescOption),
    recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType
  };
  if (format.minified) {
    format.compact = true;
    format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
  } else {
    format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.indexOf("@license") >= 0 || value.indexOf("@preserve") >= 0);
  }
  if (format.compact === "auto") {
    format.compact = code.length > 500000;
    if (format.compact) {
      console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
    }
  }
  if (format.compact) {
    format.indent.adjustMultilineComment = false;
  }
  return format;
 }
 class CodeGenerator {
  constructor(ast, opts, code) {
    this._generator = new Generator(ast, opts, code);
  }
  generate() {
    return this._generator.generate();
  }
 }
 exports.CodeGenerator = CodeGenerator;
 function _default(ast, opts, code) {
  const gen = new Generator(ast, opts, code);
  return gen.generate();
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/node/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/node/index.js
@ -0,0 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.needsWhitespace = needsWhitespace;
 exports.needsWhitespaceBefore = needsWhitespaceBefore;
 exports.needsWhitespaceAfter = needsWhitespaceAfter;
 exports.needsParens = needsParens;
 var whitespace = _interopRequireWildcard(require("./whitespace"));
 var parens = _interopRequireWildcard(require("./parentheses"));
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function expandAliases(obj) {
  const newObj = {};
  function add(type, func) {
    const fn = newObj[type];
    newObj[type] = fn ? function (node, parent, stack) {
      const result = fn(node, parent, stack);
      return result == null ? func(node, parent, stack) : result;
    } : func;
  }
  for (const type of Object.keys(obj)) {
    const aliases = t.FLIPPED_ALIAS_KEYS[type];
    if (aliases) {
      for (const alias of aliases) {
        add(alias, obj[type]);
      }
    } else {
      add(type, obj[type]);
    }
  }
  return newObj;
 }
 const expandedParens = expandAliases(parens);
 const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
 const expandedWhitespaceList = expandAliases(whitespace.list);
 function find(obj, node, parent, printStack) {
  const fn = obj[node.type];
  return fn ? fn(node, parent, printStack) : null;
 }
 function isOrHasCallExpression(node) {
  if (t.isCallExpression(node)) {
    return true;
  }
  return t.isMemberExpression(node) && isOrHasCallExpression(node.object);
 }
 function needsWhitespace(node, parent, type) {
  if (!node) return 0;
  if (t.isExpressionStatement(node)) {
    node = node.expression;
  }
  let linesInfo = find(expandedWhitespaceNodes, node, parent);
  if (!linesInfo) {
    const items = find(expandedWhitespaceList, node, parent);
    if (items) {
      for (let i = 0; i < items.length; i++) {
        linesInfo = needsWhitespace(items[i], node, type);
        if (linesInfo) break;
      }
    }
  }
  if (typeof linesInfo === "object" && linesInfo !== null) {
    return linesInfo[type] || 0;
  }
  return 0;
 }
 function needsWhitespaceBefore(node, parent) {
  return needsWhitespace(node, parent, "before");
 }
 function needsWhitespaceAfter(node, parent) {
  return needsWhitespace(node, parent, "after");
 }
 function needsParens(node, parent, printStack) {
  if (!parent) return false;
  if (t.isNewExpression(parent) && parent.callee === node) {
    if (isOrHasCallExpression(node)) return true;
  }
  return find(expandedParens, node, parent, printStack);
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/node/parentheses.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/node/parentheses.js
@ -0,0 +1,253 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.NullableTypeAnnotation = NullableTypeAnnotation;
 exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
 exports.UpdateExpression = UpdateExpression;
 exports.ObjectExpression = ObjectExpression;
 exports.DoExpression = DoExpression;
 exports.Binary = Binary;
 exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
 exports.TSAsExpression = TSAsExpression;
 exports.TSTypeAssertion = TSTypeAssertion;
 exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
 exports.TSInferType = TSInferType;
 exports.BinaryExpression = BinaryExpression;
 exports.SequenceExpression = SequenceExpression;
 exports.AwaitExpression = exports.YieldExpression = YieldExpression;
 exports.ClassExpression = ClassExpression;
 exports.UnaryLike = UnaryLike;
 exports.FunctionExpression = FunctionExpression;
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
 exports.ConditionalExpression = ConditionalExpression;
 exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
 exports.AssignmentExpression = AssignmentExpression;
 exports.LogicalExpression = LogicalExpression;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const PRECEDENCE = {
  "||": 0,
  "??": 0,
  "&&": 1,
  "|": 2,
  "^": 3,
  "&": 4,
  "==": 5,
  "===": 5,
  "!=": 5,
  "!==": 5,
  "<": 6,
  ">": 6,
  "<=": 6,
  ">=": 6,
  in: 6,
  instanceof: 6,
  ">>": 7,
  "<<": 7,
  ">>>": 7,
  "+": 8,
  "-": 8,
  "*": 9,
  "/": 9,
  "%": 9,
  "**": 10
 };
 const isClassExtendsClause = (node, parent) => (t.isClassDeclaration(parent) || t.isClassExpression(parent)) && parent.superClass === node;
 const hasPostfixPart = (node, parent) => (t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) && parent.object === node || (t.isCallExpression(parent) || t.isOptionalCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node || t.isTaggedTemplateExpression(parent) && parent.tag === node || t.isTSNonNullExpression(parent);
 function NullableTypeAnnotation(node, parent) {
  return t.isArrayTypeAnnotation(parent);
 }
 function FunctionTypeAnnotation(node, parent, printStack) {
  return t.isUnionTypeAnnotation(parent) || t.isIntersectionTypeAnnotation(parent) || t.isArrayTypeAnnotation(parent) || t.isTypeAnnotation(parent) && t.isArrowFunctionExpression(printStack[printStack.length - 3]);
 }
 function UpdateExpression(node, parent) {
  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
 }
 function ObjectExpression(node, parent, printStack) {
  return isFirstInStatement(printStack, {
    considerArrow: true
  });
 }
 function DoExpression(node, parent, printStack) {
  return isFirstInStatement(printStack);
 }
 function Binary(node, parent) {
  if (node.operator === "**" && t.isBinaryExpression(parent, {
    operator: "**"
  })) {
    return parent.left === node;
  }
  if (isClassExtendsClause(node, parent)) {
    return true;
  }
  if (hasPostfixPart(node, parent) || t.isUnaryLike(parent) || t.isAwaitExpression(parent)) {
    return true;
  }
  if (t.isBinary(parent)) {
    const parentOp = parent.operator;
    const parentPos = PRECEDENCE[parentOp];
    const nodeOp = node.operator;
    const nodePos = PRECEDENCE[nodeOp];
    if (parentPos === nodePos && parent.right === node && !t.isLogicalExpression(parent) || parentPos > nodePos) {
      return true;
    }
  }
 }
 function UnionTypeAnnotation(node, parent) {
  return t.isArrayTypeAnnotation(parent) || t.isNullableTypeAnnotation(parent) || t.isIntersectionTypeAnnotation(parent) || t.isUnionTypeAnnotation(parent);
 }
 function TSAsExpression() {
  return true;
 }
 function TSTypeAssertion() {
  return true;
 }
 function TSUnionType(node, parent) {
  return t.isTSArrayType(parent) || t.isTSOptionalType(parent) || t.isTSIntersectionType(parent) || t.isTSUnionType(parent) || t.isTSRestType(parent);
 }
 function TSInferType(node, parent) {
  return t.isTSArrayType(parent) || t.isTSOptionalType(parent);
 }
 function BinaryExpression(node, parent) {
  return node.operator === "in" && (t.isVariableDeclarator(parent) || t.isFor(parent));
 }
 function SequenceExpression(node, parent) {
  if (t.isForStatement(parent) || t.isThrowStatement(parent) || t.isReturnStatement(parent) || t.isIfStatement(parent) && parent.test === node || t.isWhileStatement(parent) && parent.test === node || t.isForInStatement(parent) && parent.right === node || t.isSwitchStatement(parent) && parent.discriminant === node || t.isExpressionStatement(parent) && parent.expression === node) {
    return false;
  }
  return true;
 }
 function YieldExpression(node, parent) {
  return t.isBinary(parent) || t.isUnaryLike(parent) || hasPostfixPart(node, parent) || t.isAwaitExpression(parent) && t.isYieldExpression(node) || t.isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent);
 }
 function ClassExpression(node, parent, printStack) {
  return isFirstInStatement(printStack, {
    considerDefaultExports: true
  });
 }
 function UnaryLike(node, parent) {
  return hasPostfixPart(node, parent) || t.isBinaryExpression(parent, {
    operator: "**",
    left: node
  }) || isClassExtendsClause(node, parent);
 }
 function FunctionExpression(node, parent, printStack) {
  return isFirstInStatement(printStack, {
    considerDefaultExports: true
  });
 }
 function ArrowFunctionExpression(node, parent) {
  return t.isExportDeclaration(parent) || ConditionalExpression(node, parent);
 }
 function ConditionalExpression(node, parent) {
  if (t.isUnaryLike(parent) || t.isBinary(parent) || t.isConditionalExpression(parent, {
    test: node
  }) || t.isAwaitExpression(parent) || t.isTSTypeAssertion(parent) || t.isTSAsExpression(parent)) {
    return true;
  }
  return UnaryLike(node, parent);
 }
 function OptionalMemberExpression(node, parent) {
  return t.isCallExpression(parent, {
    callee: node
  }) || t.isMemberExpression(parent, {
    object: node
  });
 }
 function AssignmentExpression(node, parent, printStack) {
  if (t.isObjectPattern(node.left)) {
    return true;
  } else {
    return ConditionalExpression(node, parent, printStack);
  }
 }
 function LogicalExpression(node, parent) {
  switch (node.operator) {
    case "||":
      if (!t.isLogicalExpression(parent)) return false;
      return parent.operator === "??" || parent.operator === "&&";
    case "&&":
      return t.isLogicalExpression(parent, {
        operator: "??"
      });
    case "??":
      return t.isLogicalExpression(parent) && parent.operator !== "??";
  }
 }
 function isFirstInStatement(printStack, {
  considerArrow = false,
  considerDefaultExports = false
 } = {}) {
  let i = printStack.length - 1;
  let node = printStack[i];
  i--;
  let parent = printStack[i];
  while (i > 0) {
    if (t.isExpressionStatement(parent, {
      expression: node
    }) || considerDefaultExports && t.isExportDefaultDeclaration(parent, {
      declaration: node
    }) || considerArrow && t.isArrowFunctionExpression(parent, {
      body: node
    })) {
      return true;
    }
    if (hasPostfixPart(node, parent) && !t.isNewExpression(parent) || t.isSequenceExpression(parent) && parent.expressions[0] === node || t.isConditional(parent, {
      test: node
    }) || t.isBinary(parent, {
      left: node
    }) || t.isAssignmentExpression(parent, {
      left: node
    })) {
      node = parent;
      i--;
      parent = printStack[i];
    } else {
      return false;
    }
  }
  return false;
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/node/whitespace.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/node/whitespace.js
@ -0,0 +1,195 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.list = exports.nodes = void 0;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function crawl(node, state = {}) {
  if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
    crawl(node.object, state);
    if (node.computed) crawl(node.property, state);
  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
    crawl(node.left, state);
    crawl(node.right, state);
  } else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
    state.hasCall = true;
    crawl(node.callee, state);
  } else if (t.isFunction(node)) {
    state.hasFunction = true;
  } else if (t.isIdentifier(node)) {
    state.hasHelper = state.hasHelper || isHelper(node.callee);
  }
  return state;
 }
 function isHelper(node) {
  if (t.isMemberExpression(node)) {
    return isHelper(node.object) || isHelper(node.property);
  } else if (t.isIdentifier(node)) {
    return node.name === "require" || node.name[0] === "_";
  } else if (t.isCallExpression(node)) {
    return isHelper(node.callee);
  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
    return t.isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
  } else {
    return false;
  }
 }
 function isType(node) {
  return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) || t.isIdentifier(node) || t.isMemberExpression(node);
 }
 const nodes = {
  AssignmentExpression(node) {
    const state = crawl(node.right);
    if (state.hasCall && state.hasHelper || state.hasFunction) {
      return {
        before: state.hasFunction,
        after: true
      };
    }
  },
  SwitchCase(node, parent) {
    return {
      before: node.consequent.length || parent.cases[0] === node,
      after: !node.consequent.length && parent.cases[parent.cases.length - 1] === node
    };
  },
  LogicalExpression(node) {
    if (t.isFunction(node.left) || t.isFunction(node.right)) {
      return {
        after: true
      };
    }
  },
  Literal(node) {
    if (node.value === "use strict") {
      return {
        after: true
      };
    }
  },
  CallExpression(node) {
    if (t.isFunction(node.callee) || isHelper(node)) {
      return {
        before: true,
        after: true
      };
    }
  },
  OptionalCallExpression(node) {
    if (t.isFunction(node.callee)) {
      return {
        before: true,
        after: true
      };
    }
  },
  VariableDeclaration(node) {
    for (let i = 0; i < node.declarations.length; i++) {
      const declar = node.declarations[i];
      let enabled = isHelper(declar.id) && !isType(declar.init);
      if (!enabled) {
        const state = crawl(declar.init);
        enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
      }
      if (enabled) {
        return {
          before: true,
          after: true
        };
      }
    }
  },
  IfStatement(node) {
    if (t.isBlockStatement(node.consequent)) {
      return {
        before: true,
        after: true
      };
    }
  }
 };
 exports.nodes = nodes;
 nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
  if (parent.properties[0] === node) {
    return {
      before: true
    };
  }
 };
 nodes.ObjectTypeCallProperty = function (node, parent) {
  if (parent.callProperties[0] === node && (!parent.properties || !parent.properties.length)) {
    return {
      before: true
    };
  }
 };
 nodes.ObjectTypeIndexer = function (node, parent) {
  if (parent.indexers[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length)) {
    return {
      before: true
    };
  }
 };
 nodes.ObjectTypeInternalSlot = function (node, parent) {
  if (parent.internalSlots[0] === node && (!parent.properties || !parent.properties.length) && (!parent.callProperties || !parent.callProperties.length) && (!parent.indexers || !parent.indexers.length)) {
    return {
      before: true
    };
  }
 };
 const list = {
  VariableDeclaration(node) {
    return node.declarations.map(decl => decl.init);
  },
  ArrayExpression(node) {
    return node.elements;
  },
  ObjectExpression(node) {
    return node.properties;
  }
 };
 exports.list = list;
 [["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
  if (typeof amounts === "boolean") {
    amounts = {
      after: amounts,
      before: amounts
    };
  }
  [type].concat(t.FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
    nodes[type] = function () {
      return amounts;
    };
  });
 });
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/printer.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/printer.js
@ -0,0 +1,498 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = void 0;
 var _isInteger = _interopRequireDefault(require("lodash/isInteger"));
 var _repeat = _interopRequireDefault(require("lodash/repeat"));
 var _buffer = _interopRequireDefault(require("./buffer"));
 var n = _interopRequireWildcard(require("./node"));
 var t = _interopRequireWildcard(require("@babel/types"));
 var generatorFunctions = _interopRequireWildcard(require("./generators"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const SCIENTIFIC_NOTATION = /e/i;
 const ZERO_DECIMAL_INTEGER = /\.0+$/;
 const NON_DECIMAL_LITERAL = /^0[box]/;
 const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
 class Printer {
  constructor(format, map) {
    this.inForStatementInitCounter = 0;
    this._printStack = [];
    this._indent = 0;
    this._insideAux = false;
    this._printedCommentStarts = {};
    this._parenPushNewlineState = null;
    this._noLineTerminator = false;
    this._printAuxAfterOnNextUserNode = false;
    this._printedComments = new WeakSet();
    this._endsWithInteger = false;
    this._endsWithWord = false;
    this.format = format || {};
    this._buf = new _buffer.default(map);
  }
  generate(ast) {
    this.print(ast);
    this._maybeAddAuxComment();
    return this._buf.get();
  }
  indent() {
    if (this.format.compact || this.format.concise) return;
    this._indent++;
  }
  dedent() {
    if (this.format.compact || this.format.concise) return;
    this._indent--;
  }
  semicolon(force = false) {
    this._maybeAddAuxComment();
    this._append(";", !force);
  }
  rightBrace() {
    if (this.format.minified) {
      this._buf.removeLastSemicolon();
    }
    this.token("}");
  }
  space(force = false) {
    if (this.format.compact) return;
    if (this._buf.hasContent() && !this.endsWith(" ") && !this.endsWith("\n") || force) {
      this._space();
    }
  }
  word(str) {
    if (this._endsWithWord || this.endsWith("/") && str.indexOf("/") === 0) {
      this._space();
    }
    this._maybeAddAuxComment();
    this._append(str);
    this._endsWithWord = true;
  }
  number(str) {
    this.word(str);
    this._endsWithInteger = (0, _isInteger.default)(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str[str.length - 1] !== ".";
  }
  token(str) {
    if (str === "--" && this.endsWith("!") || str[0] === "+" && this.endsWith("+") || str[0] === "-" && this.endsWith("-") || str[0] === "." && this._endsWithInteger) {
      this._space();
    }
    this._maybeAddAuxComment();
    this._append(str);
  }
  newline(i) {
    if (this.format.retainLines || this.format.compact) return;
    if (this.format.concise) {
      this.space();
      return;
    }
    if (this.endsWith("\n\n")) return;
    if (typeof i !== "number") i = 1;
    i = Math.min(2, i);
    if (this.endsWith("{\n") || this.endsWith(":\n")) i--;
    if (i <= 0) return;
    for (let j = 0; j < i; j++) {
      this._newline();
    }
  }
  endsWith(str) {
    return this._buf.endsWith(str);
  }
  removeTrailingNewline() {
    this._buf.removeTrailingNewline();
  }
  exactSource(loc, cb) {
    this._catchUp("start", loc);
    this._buf.exactSource(loc, cb);
  }
  source(prop, loc) {
    this._catchUp(prop, loc);
    this._buf.source(prop, loc);
  }
  withSource(prop, loc, cb) {
    this._catchUp(prop, loc);
    this._buf.withSource(prop, loc, cb);
  }
  _space() {
    this._append(" ", true);
  }
  _newline() {
    this._append("\n", true);
  }
  _append(str, queue = false) {
    this._maybeAddParen(str);
    this._maybeIndent(str);
    if (queue) this._buf.queue(str);else this._buf.append(str);
    this._endsWithWord = false;
    this._endsWithInteger = false;
  }
  _maybeIndent(str) {
    if (this._indent && this.endsWith("\n") && str[0] !== "\n") {
      this._buf.queue(this._getIndent());
    }
  }
  _maybeAddParen(str) {
    const parenPushNewlineState = this._parenPushNewlineState;
    if (!parenPushNewlineState) return;
    let i;
    for (i = 0; i < str.length && str[i] === " "; i++) continue;
    if (i === str.length) {
      return;
    }
    const cha = str[i];
    if (cha !== "\n") {
      if (cha !== "/" || i + 1 === str.length) {
        this._parenPushNewlineState = null;
        return;
      }
      const chaPost = str[i + 1];
      if (chaPost === "*") {
        if (PURE_ANNOTATION_RE.test(str.slice(i + 2, str.length - 2))) {
          return;
        }
      } else if (chaPost !== "/") {
        this._parenPushNewlineState = null;
        return;
      }
    }
    this.token("(");
    this.indent();
    parenPushNewlineState.printed = true;
  }
  _catchUp(prop, loc) {
    if (!this.format.retainLines) return;
    const pos = loc ? loc[prop] : null;
    if (pos && pos.line !== null) {
      const count = pos.line - this._buf.getCurrentLine();
      for (let i = 0; i < count; i++) {
        this._newline();
      }
    }
  }
  _getIndent() {
    return (0, _repeat.default)(this.format.indent.style, this._indent);
  }
  startTerminatorless(isLabel = false) {
    if (isLabel) {
      this._noLineTerminator = true;
      return null;
    } else {
      return this._parenPushNewlineState = {
        printed: false
      };
    }
  }
  endTerminatorless(state) {
    this._noLineTerminator = false;
    if (state && state.printed) {
      this.dedent();
      this.newline();
      this.token(")");
    }
  }
  print(node, parent) {
    if (!node) return;
    const oldConcise = this.format.concise;
    if (node._compact) {
      this.format.concise = true;
    }
    const printMethod = this[node.type];
    if (!printMethod) {
      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
    }
    this._printStack.push(node);
    const oldInAux = this._insideAux;
    this._insideAux = !node.loc;
    this._maybeAddAuxComment(this._insideAux && !oldInAux);
    let needsParens = n.needsParens(node, parent, this._printStack);
    if (this.format.retainFunctionParens && node.type === "FunctionExpression" && node.extra && node.extra.parenthesized) {
      needsParens = true;
    }
    if (needsParens) this.token("(");
    this._printLeadingComments(node);
    const loc = t.isProgram(node) || t.isFile(node) ? null : node.loc;
    this.withSource("start", loc, () => {
      printMethod.call(this, node, parent);
    });
    this._printTrailingComments(node);
    if (needsParens) this.token(")");
    this._printStack.pop();
    this.format.concise = oldConcise;
    this._insideAux = oldInAux;
  }
  _maybeAddAuxComment(enteredPositionlessNode) {
    if (enteredPositionlessNode) this._printAuxBeforeComment();
    if (!this._insideAux) this._printAuxAfterComment();
  }
  _printAuxBeforeComment() {
    if (this._printAuxAfterOnNextUserNode) return;
    this._printAuxAfterOnNextUserNode = true;
    const comment = this.format.auxiliaryCommentBefore;
    if (comment) {
      this._printComment({
        type: "CommentBlock",
        value: comment
      });
    }
  }
  _printAuxAfterComment() {
    if (!this._printAuxAfterOnNextUserNode) return;
    this._printAuxAfterOnNextUserNode = false;
    const comment = this.format.auxiliaryCommentAfter;
    if (comment) {
      this._printComment({
        type: "CommentBlock",
        value: comment
      });
    }
  }
  getPossibleRaw(node) {
    const extra = node.extra;
    if (extra && extra.raw != null && extra.rawValue != null && node.value === extra.rawValue) {
      return extra.raw;
    }
  }
  printJoin(nodes, parent, opts = {}) {
    if (!nodes || !nodes.length) return;
    if (opts.indent) this.indent();
    const newlineOpts = {
      addNewlines: opts.addNewlines
    };
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node) continue;
      if (opts.statement) this._printNewline(true, node, parent, newlineOpts);
      this.print(node, parent);
      if (opts.iterator) {
        opts.iterator(node, i);
      }
      if (opts.separator && i < nodes.length - 1) {
        opts.separator.call(this);
      }
      if (opts.statement) this._printNewline(false, node, parent, newlineOpts);
    }
    if (opts.indent) this.dedent();
  }
  printAndIndentOnComments(node, parent) {
    const indent = node.leadingComments && node.leadingComments.length > 0;
    if (indent) this.indent();
    this.print(node, parent);
    if (indent) this.dedent();
  }
  printBlock(parent) {
    const node = parent.body;
    if (!t.isEmptyStatement(node)) {
      this.space();
    }
    this.print(node, parent);
  }
  _printTrailingComments(node) {
    this._printComments(this._getComments(false, node));
  }
  _printLeadingComments(node) {
    this._printComments(this._getComments(true, node), true);
  }
  printInnerComments(node, indent = true) {
    if (!node.innerComments || !node.innerComments.length) return;
    if (indent) this.indent();
    this._printComments(node.innerComments);
    if (indent) this.dedent();
  }
  printSequence(nodes, parent, opts = {}) {
    opts.statement = true;
    return this.printJoin(nodes, parent, opts);
  }
  printList(items, parent, opts = {}) {
    if (opts.separator == null) {
      opts.separator = commaSeparator;
    }
    return this.printJoin(items, parent, opts);
  }
  _printNewline(leading, node, parent, opts) {
    if (this.format.retainLines || this.format.compact) return;
    if (this.format.concise) {
      this.space();
      return;
    }
    let lines = 0;
    if (this._buf.hasContent()) {
      if (!leading) lines++;
      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
      const needs = leading ? n.needsWhitespaceBefore : n.needsWhitespaceAfter;
      if (needs(node, parent)) lines++;
    }
    this.newline(lines);
  }
  _getComments(leading, node) {
    return node && (leading ? node.leadingComments : node.trailingComments) || [];
  }
  _printComment(comment, skipNewLines) {
    if (!this.format.shouldPrintComment(comment.value)) return;
    if (comment.ignore) return;
    if (this._printedComments.has(comment)) return;
    this._printedComments.add(comment);
    if (comment.start != null) {
      if (this._printedCommentStarts[comment.start]) return;
      this._printedCommentStarts[comment.start] = true;
    }
    const isBlockComment = comment.type === "CommentBlock";
    const printNewLines = isBlockComment && !skipNewLines && !this._noLineTerminator;
    if (printNewLines && this._buf.hasContent()) this.newline(1);
    if (!this.endsWith("[") && !this.endsWith("{")) this.space();
    let val = !isBlockComment && !this._noLineTerminator ? `//${comment.value}\n` : `/*${comment.value}*/`;
    if (isBlockComment && this.format.indent.adjustMultilineComment) {
      const offset = comment.loc && comment.loc.start.column;
      if (offset) {
        const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
        val = val.replace(newlineRegex, "\n");
      }
      const indentSize = Math.max(this._getIndent().length, this._buf.getCurrentColumn());
      val = val.replace(/\n(?!$)/g, `\n${(0, _repeat.default)(" ", indentSize)}`);
    }
    if (this.endsWith("/")) this._space();
    this.withSource("start", comment.loc, () => {
      this._append(val);
    });
    if (printNewLines) this.newline(1);
  }
  _printComments(comments, inlinePureAnnotation) {
    if (!comments || !comments.length) return;
    if (inlinePureAnnotation && comments.length === 1 && PURE_ANNOTATION_RE.test(comments[0].value)) {
      this._printComment(comments[0], this._buf.hasContent() && !this.endsWith("\n"));
    } else {
      for (const comment of comments) {
        this._printComment(comment);
      }
    }
  }
 }
 exports.default = Printer;
 Object.assign(Printer.prototype, generatorFunctions);
 function commaSeparator() {
  this.token(",");
  this.space();
 }
--- a/node_modules/ssb-server/node_modules/@babel/generator/lib/source-map.js
+++ b/node_modules/ssb-server/node_modules/@babel/generator/lib/source-map.js
@ -0,0 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = void 0;
 var _sourceMap = _interopRequireDefault(require("source-map"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class SourceMap {
  constructor(opts, code) {
    this._cachedMap = null;
    this._code = code;
    this._opts = opts;
    this._rawMappings = [];
  }
  get() {
    if (!this._cachedMap) {
      const map = this._cachedMap = new _sourceMap.default.SourceMapGenerator({
        sourceRoot: this._opts.sourceRoot
      });
      const code = this._code;
      if (typeof code === "string") {
        map.setSourceContent(this._opts.sourceFileName.replace(/\\/g, "/"), code);
      } else if (typeof code === "object") {
        Object.keys(code).forEach(sourceFileName => {
          map.setSourceContent(sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
        });
      }
      this._rawMappings.forEach(mapping => map.addMapping(mapping), map);
    }
    return this._cachedMap.toJSON();
  }
  getRawMappings() {
    return this._rawMappings.slice();
  }
  mark(generatedLine, generatedColumn, line, column, identifierName, filename, force) {
    if (this._lastGenLine !== generatedLine && line === null) return;
    if (!force && this._lastGenLine === generatedLine && this._lastSourceLine === line && this._lastSourceColumn === column) {
      return;
    }
    this._cachedMap = null;
    this._lastGenLine = generatedLine;
    this._lastSourceLine = line;
    this._lastSourceColumn = column;
    this._rawMappings.push({
      name: identifierName || undefined,
      generated: {
        line: generatedLine,
        column: generatedColumn
      },
      source: line == null ? undefined : (filename || this._opts.sourceFileName).replace(/\\/g, "/"),
      original: line == null ? undefined : {
        line: line,
        column: column
      }
    });
  }
 }
 exports.default = SourceMap;
--- a/node_modules/ssb-server/node_modules/@babel/generator/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/generator/package.json
@ -0,0 +1,27 @@
 {
  "name": "@babel/generator",
  "version": "7.9.6",
  "description": "Turns an AST into code.",
  "author": "Sebastian McKenzie <sebmck@gmail.com>",
  "homepage": "https://babeljs.io/",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-generator",
  "main": "lib/index.js",
  "files": [
    "lib"
  ],
  "dependencies": {
    "@babel/types": "^7.9.6",
    "jsesc": "^2.5.1",
    "lodash": "^4.17.13",
    "source-map": "^0.5.0"
  },
  "devDependencies": {
    "@babel/helper-fixtures": "^7.8.6",
    "@babel/parser": "^7.9.6"
  },
  "gitHead": "9c2846bcacc75aa931ea9d556950c2113765d43d"
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-function-name/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/helper-function-name/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/helper-function-name/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/helper-function-name/README.md
@ -0,0 +1,19 @@
 # @babel/helper-function-name
 > Helper function to change the property 'name' of every function
 See our website [@babel/helper-function-name](https://babeljs.io/docs/en/next/babel-helper-function-name.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/helper-function-name
 ```
 or using yarn:
 ```sh
 yarn add @babel/helper-function-name --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/helper-function-name/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-function-name/lib/index.js
@ -0,0 +1,178 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = _default;
 var _helperGetFunctionArity = _interopRequireDefault(require("@babel/helper-get-function-arity"));
 var _template = _interopRequireDefault(require("@babel/template"));
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const buildPropertyMethodAssignmentWrapper = (0, _template.default)(`
  (function (FUNCTION_KEY) {
    function FUNCTION_ID() {
      return FUNCTION_KEY.apply(this, arguments);
    }
    FUNCTION_ID.toString = function () {
      return FUNCTION_KEY.toString();
    }
    return FUNCTION_ID;
  })(FUNCTION)
 `);
 const buildGeneratorPropertyMethodAssignmentWrapper = (0, _template.default)(`
  (function (FUNCTION_KEY) {
    function* FUNCTION_ID() {
      return yield* FUNCTION_KEY.apply(this, arguments);
    }
    FUNCTION_ID.toString = function () {
      return FUNCTION_KEY.toString();
    };
    return FUNCTION_ID;
  })(FUNCTION)
 `);
 const visitor = {
  "ReferencedIdentifier|BindingIdentifier"(path, state) {
    if (path.node.name !== state.name) return;
    const localDeclar = path.scope.getBindingIdentifier(state.name);
    if (localDeclar !== state.outerDeclar) return;
    state.selfReference = true;
    path.stop();
  }
 };
 function getNameFromLiteralId(id) {
  if (t.isNullLiteral(id)) {
    return "null";
  }
  if (t.isRegExpLiteral(id)) {
    return `_${id.pattern}_${id.flags}`;
  }
  if (t.isTemplateLiteral(id)) {
    return id.quasis.map(quasi => quasi.value.raw).join("");
  }
  if (id.value !== undefined) {
    return id.value + "";
  }
  return "";
 }
 function wrap(state, method, id, scope) {
  if (state.selfReference) {
    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
      scope.rename(id.name);
    } else {
      if (!t.isFunction(method)) return;
      let build = buildPropertyMethodAssignmentWrapper;
      if (method.generator) {
        build = buildGeneratorPropertyMethodAssignmentWrapper;
      }
      const template = build({
        FUNCTION: method,
        FUNCTION_ID: id,
        FUNCTION_KEY: scope.generateUidIdentifier(id.name)
      }).expression;
      const params = template.callee.body.body[0].params;
      for (let i = 0, len = (0, _helperGetFunctionArity.default)(method); i < len; i++) {
        params.push(scope.generateUidIdentifier("x"));
      }
      return template;
    }
  }
  method.id = id;
  scope.getProgramParent().references[id.name] = true;
 }
 function visit(node, name, scope) {
  const state = {
    selfAssignment: false,
    selfReference: false,
    outerDeclar: scope.getBindingIdentifier(name),
    references: [],
    name: name
  };
  const binding = scope.getOwnBinding(name);
  if (binding) {
    if (binding.kind === "param") {
      state.selfReference = true;
    } else {}
  } else if (state.outerDeclar || scope.hasGlobal(name)) {
    scope.traverse(node, visitor, state);
  }
  return state;
 }
 function _default({
  node,
  parent,
  scope,
  id
 }, localBinding = false) {
  if (node.id) return;
  if ((t.isObjectProperty(parent) || t.isObjectMethod(parent, {
    kind: "method"
  })) && (!parent.computed || t.isLiteral(parent.key))) {
    id = parent.key;
  } else if (t.isVariableDeclarator(parent)) {
    id = parent.id;
    if (t.isIdentifier(id) && !localBinding) {
      const binding = scope.parent.getBinding(id.name);
      if (binding && binding.constant && scope.getBinding(id.name) === binding) {
        node.id = t.cloneNode(id);
        node.id[t.NOT_LOCAL_BINDING] = true;
        return;
      }
    }
  } else if (t.isAssignmentExpression(parent, {
    operator: "="
  })) {
    id = parent.left;
  } else if (!id) {
    return;
  }
  let name;
  if (id && t.isLiteral(id)) {
    name = getNameFromLiteralId(id);
  } else if (id && t.isIdentifier(id)) {
    name = id.name;
  }
  if (name === undefined) {
    return;
  }
  name = t.toBindingIdentifierName(name);
  id = t.identifier(name);
  id[t.NOT_LOCAL_BINDING] = true;
  const state = visit(node, name, scope);
  return wrap(state, node, id, scope) || node;
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-function-name/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/helper-function-name/package.json
@ -0,0 +1,17 @@
 {
  "name": "@babel/helper-function-name",
  "version": "7.9.5",
  "description": "Helper function to change the property 'name' of every function",
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-function-name",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "main": "lib/index.js",
  "dependencies": {
    "@babel/helper-get-function-arity": "^7.8.3",
    "@babel/template": "^7.8.3",
    "@babel/types": "^7.9.5"
  },
  "gitHead": "5b97e77e030cf3853a147fdff81844ea4026219d"
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/README.md
@ -0,0 +1,19 @@
 # @babel/helper-get-function-arity
 > Helper function to get function arity
 See our website [@babel/helper-get-function-arity](https://babeljs.io/docs/en/next/babel-helper-get-function-arity.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/helper-get-function-arity
 ```
 or using yarn:
 ```sh
 yarn add @babel/helper-get-function-arity --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/lib/index.js
@ -0,0 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = _default;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _default(node) {
  const params = node.params;
  for (let i = 0; i < params.length; i++) {
    const param = params[i];
    if (t.isAssignmentPattern(param) || t.isRestElement(param)) {
      return i;
    }
  }
  return params.length;
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/helper-get-function-arity/package.json
@ -0,0 +1,15 @@
 {
  "name": "@babel/helper-get-function-arity",
  "version": "7.8.3",
  "description": "Helper function to get function arity",
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-get-function-arity",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "main": "lib/index.js",
  "dependencies": {
    "@babel/types": "^7.8.3"
  },
  "gitHead": "a7620bd266ae1345975767bbc7abf09034437017"
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/README.md
@ -0,0 +1,19 @@
 # @babel/helper-split-export-declaration
 > 
 See our website [@babel/helper-split-export-declaration](https://babeljs.io/docs/en/next/babel-helper-split-export-declaration.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/helper-split-export-declaration
 ```
 or using yarn:
 ```sh
 yarn add @babel/helper-split-export-declaration --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/lib/index.js
@ -0,0 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = splitExportDeclaration;
 var t = _interopRequireWildcard(require("@babel/types"));
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function splitExportDeclaration(exportDeclaration) {
  if (!exportDeclaration.isExportDeclaration()) {
    throw new Error("Only export declarations can be splitted.");
  }
  const isDefault = exportDeclaration.isExportDefaultDeclaration();
  const declaration = exportDeclaration.get("declaration");
  const isClassDeclaration = declaration.isClassDeclaration();
  if (isDefault) {
    const standaloneDeclaration = declaration.isFunctionDeclaration() || isClassDeclaration;
    const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
    let id = declaration.node.id;
    let needBindingRegistration = false;
    if (!id) {
      needBindingRegistration = true;
      id = scope.generateUidIdentifier("default");
      if (standaloneDeclaration || declaration.isFunctionExpression() || declaration.isClassExpression()) {
        declaration.node.id = t.cloneNode(id);
      }
    }
    const updatedDeclaration = standaloneDeclaration ? declaration : t.variableDeclaration("var", [t.variableDeclarator(t.cloneNode(id), declaration.node)]);
    const updatedExportDeclaration = t.exportNamedDeclaration(null, [t.exportSpecifier(t.cloneNode(id), t.identifier("default"))]);
    exportDeclaration.insertAfter(updatedExportDeclaration);
    exportDeclaration.replaceWith(updatedDeclaration);
    if (needBindingRegistration) {
      scope.registerDeclaration(exportDeclaration);
    }
    return exportDeclaration;
  }
  if (exportDeclaration.get("specifiers").length > 0) {
    throw new Error("It doesn't make sense to split exported specifiers.");
  }
  const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
  const specifiers = Object.keys(bindingIdentifiers).map(name => {
    return t.exportSpecifier(t.identifier(name), t.identifier(name));
  });
  const aliasDeclar = t.exportNamedDeclaration(null, specifiers);
  exportDeclaration.insertAfter(aliasDeclar);
  exportDeclaration.replaceWith(declaration.node);
  return exportDeclaration;
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/helper-split-export-declaration/package.json
@ -0,0 +1,15 @@
 {
  "name": "@babel/helper-split-export-declaration",
  "version": "7.8.3",
  "description": "",
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-split-export-declaration",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "main": "lib/index.js",
  "dependencies": {
    "@babel/types": "^7.8.3"
  },
  "gitHead": "a7620bd266ae1345975767bbc7abf09034437017"
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/README.md
@ -0,0 +1,19 @@
 # @babel/helper-validator-identifier
 > Validate identifier/keywords name
 See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/en/next/babel-helper-validator-identifier.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/helper-validator-identifier
 ```
 or using yarn:
 ```sh
 yarn add @babel/helper-validator-identifier --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/identifier.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/identifier.js
@ -0,0 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.isIdentifierStart = isIdentifierStart;
 exports.isIdentifierChar = isIdentifierChar;
 exports.isIdentifierName = isIdentifierName;
 let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
 let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
 const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
 const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
 nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
 const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
 const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
 function isInAstralSet(code, set) {
  let pos = 0x10000;
  for (let i = 0, length = set.length; i < length; i += 2) {
    pos += set[i];
    if (pos > code) return false;
    pos += set[i + 1];
    if (pos >= code) return true;
  }
  return false;
 }
 function isIdentifierStart(code) {
  if (code < 65) return code === 36;
  if (code <= 90) return true;
  if (code < 97) return code === 95;
  if (code <= 122) return true;
  if (code <= 0xffff) {
    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
  }
  return isInAstralSet(code, astralIdentifierStartCodes);
 }
 function isIdentifierChar(code) {
  if (code < 48) return code === 36;
  if (code < 58) return true;
  if (code < 65) return false;
  if (code <= 90) return true;
  if (code < 97) return code === 95;
  if (code <= 122) return true;
  if (code <= 0xffff) {
    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
  }
  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
 }
 function isIdentifierName(name) {
  let isFirst = true;
  for (let _i = 0, _Array$from = Array.from(name); _i < _Array$from.length; _i++) {
    const char = _Array$from[_i];
    const cp = char.codePointAt(0);
    if (isFirst) {
      if (!isIdentifierStart(cp)) {
        return false;
      }
      isFirst = false;
    } else if (!isIdentifierChar(cp)) {
      return false;
    }
  }
  return !isFirst;
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/index.js
@ -0,0 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 Object.defineProperty(exports, "isIdentifierName", {
  enumerable: true,
  get: function () {
    return _identifier.isIdentifierName;
  }
 });
 Object.defineProperty(exports, "isIdentifierChar", {
  enumerable: true,
  get: function () {
    return _identifier.isIdentifierChar;
  }
 });
 Object.defineProperty(exports, "isIdentifierStart", {
  enumerable: true,
  get: function () {
    return _identifier.isIdentifierStart;
  }
 });
 Object.defineProperty(exports, "isReservedWord", {
  enumerable: true,
  get: function () {
    return _keyword.isReservedWord;
  }
 });
 Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
  enumerable: true,
  get: function () {
    return _keyword.isStrictBindOnlyReservedWord;
  }
 });
 Object.defineProperty(exports, "isStrictBindReservedWord", {
  enumerable: true,
  get: function () {
    return _keyword.isStrictBindReservedWord;
  }
 });
 Object.defineProperty(exports, "isStrictReservedWord", {
  enumerable: true,
  get: function () {
    return _keyword.isStrictReservedWord;
  }
 });
 Object.defineProperty(exports, "isKeyword", {
  enumerable: true,
  get: function () {
    return _keyword.isKeyword;
  }
 });
 var _identifier = require("./identifier");
 var _keyword = require("./keyword");
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/keyword.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/lib/keyword.js
@ -0,0 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.isReservedWord = isReservedWord;
 exports.isStrictReservedWord = isStrictReservedWord;
 exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
 exports.isStrictBindReservedWord = isStrictBindReservedWord;
 exports.isKeyword = isKeyword;
 const reservedWords = {
  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
  strictBind: ["eval", "arguments"]
 };
 const keywords = new Set(reservedWords.keyword);
 const reservedWordsStrictSet = new Set(reservedWords.strict);
 const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
 function isReservedWord(word, inModule) {
  return inModule && word === "await" || word === "enum";
 }
 function isStrictReservedWord(word, inModule) {
  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
 }
 function isStrictBindOnlyReservedWord(word) {
  return reservedWordsStrictBindSet.has(word);
 }
 function isStrictBindReservedWord(word, inModule) {
  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
 }
 function isKeyword(word) {
  return keywords.has(word);
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/package.json
@ -0,0 +1,17 @@
 {
  "name": "@babel/helper-validator-identifier",
  "version": "7.9.5",
  "description": "Validate identifier/keywords name",
  "repository": "https://github.com/babel/babel/tree/master/packages/babel-helper-validator-identifier",
  "license": "MIT",
  "publishConfig": {
    "access": "public"
  },
  "main": "./lib/index.js",
  "exports": "./lib/index.js",
  "devDependencies": {
    "charcodes": "^0.2.0",
    "unicode-13.0.0": "^0.8.0"
  },
  "gitHead": "5b97e77e030cf3853a147fdff81844ea4026219d"
 }
--- a/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/scripts/generate-identifier-regex.js
+++ b/node_modules/ssb-server/node_modules/@babel/helper-validator-identifier/scripts/generate-identifier-regex.js
@ -0,0 +1,75 @@
 "use strict";
 // Always use the latest available version of Unicode!
 // https://tc39.github.io/ecma262/#sec-conformance
 const version = "13.0.0";
 const start = require("unicode-" +
  version +
  "/Binary_Property/ID_Start/code-points.js").filter(function(ch) {
  return ch > 0x7f;
 });
 let last = -1;
 const cont = [0x200c, 0x200d].concat(
  require("unicode-" +
    version +
    "/Binary_Property/ID_Continue/code-points.js").filter(function(ch) {
    return ch > 0x7f && search(start, ch, last + 1) == -1;
  })
 );
 function search(arr, ch, starting) {
  for (let i = starting; arr[i] <= ch && i < arr.length; last = i++) {
    if (arr[i] === ch) return i;
  }
  return -1;
 }
 function pad(str, width) {
  while (str.length < width) str = "0" + str;
  return str;
 }
 function esc(code) {
  const hex = code.toString(16);
  if (hex.length <= 2) return "\\x" + pad(hex, 2);
  else return "\\u" + pad(hex, 4);
 }
 function generate(chars) {
  const astral = [];
  let re = "";
  for (let i = 0, at = 0x10000; i < chars.length; i++) {
    const from = chars[i];
    let to = from;
    while (i < chars.length - 1 && chars[i + 1] == to + 1) {
      i++;
      to++;
    }
    if (to <= 0xffff) {
      if (from == to) re += esc(from);
      else if (from + 1 == to) re += esc(from) + esc(to);
      else re += esc(from) + "-" + esc(to);
    } else {
      astral.push(from - at, to - from);
      at = to;
    }
  }
  return { nonASCII: re, astral: astral };
 }
 const startData = generate(start);
 const contData = generate(cont);
 console.log("/* prettier-ignore */");
 console.log('let nonASCIIidentifierStartChars = "' + startData.nonASCII + '";');
 console.log("/* prettier-ignore */");
 console.log('let nonASCIIidentifierChars = "' + contData.nonASCII + '";');
 console.log("/* prettier-ignore */");
 console.log(
  "const astralIdentifierStartCodes = " + JSON.stringify(startData.astral) + ";"
 );
 console.log("/* prettier-ignore */");
 console.log(
  "const astralIdentifierCodes = " + JSON.stringify(contData.astral) + ";"
 );
--- a/node_modules/ssb-server/node_modules/@babel/highlight/LICENSE
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/LICENSE
@ -0,0 +1,22 @@
 MIT License
 Copyright (c) 2014-present Sebastian McKenzie and other contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/highlight/README.md
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/README.md
@ -0,0 +1,19 @@
 # @babel/highlight
 > Syntax highlight JavaScript strings for output in terminals.
 See our website [@babel/highlight](https://babeljs.io/docs/en/next/babel-highlight.html) for more information.
 ## Install
 Using npm:
 ```sh
 npm install --save-dev @babel/highlight
 ```
 or using yarn:
 ```sh
 yarn add @babel/highlight --dev
 ```
--- a/node_modules/ssb-server/node_modules/@babel/highlight/lib/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/lib/index.js
@ -0,0 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.shouldHighlight = shouldHighlight;
 exports.getChalk = getChalk;
 exports.default = highlight;
 var _jsTokens = _interopRequireWildcard(require("js-tokens"));
 var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
 var _chalk = _interopRequireDefault(require("chalk"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function getDefs(chalk) {
  return {
    keyword: chalk.cyan,
    capitalized: chalk.yellow,
    jsx_tag: chalk.yellow,
    punctuator: chalk.yellow,
    number: chalk.magenta,
    string: chalk.green,
    regex: chalk.magenta,
    comment: chalk.grey,
    invalid: chalk.white.bgRed.bold
  };
 }
 const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 const JSX_TAG = /^[a-z][\w-]*$/i;
 const BRACKET = /^[()[\]{}]$/;
 function getTokenType(match) {
  const [offset, text] = match.slice(-2);
  const token = (0, _jsTokens.matchToToken)(match);
  if (token.type === "name") {
    if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isReservedWord)(token.value)) {
      return "keyword";
    }
    if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "</")) {
      return "jsx_tag";
    }
    if (token.value[0] !== token.value[0].toLowerCase()) {
      return "capitalized";
    }
  }
  if (token.type === "punctuator" && BRACKET.test(token.value)) {
    return "bracket";
  }
  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
    return "punctuator";
  }
  return token.type;
 }
 function highlightTokens(defs, text) {
  return text.replace(_jsTokens.default, function (...args) {
    const type = getTokenType(args);
    const colorize = defs[type];
    if (colorize) {
      return args[0].split(NEWLINE).map(str => colorize(str)).join("\n");
    } else {
      return args[0];
    }
  });
 }
 function shouldHighlight(options) {
  return _chalk.default.supportsColor || options.forceColor;
 }
 function getChalk(options) {
  let chalk = _chalk.default;
  if (options.forceColor) {
    chalk = new _chalk.default.constructor({
      enabled: true,
      level: 1
    });
  }
  return chalk;
 }
 function highlight(code, options = {}) {
  if (shouldHighlight(options)) {
    const chalk = getChalk(options);
    const defs = getDefs(chalk);
    return highlightTokens(defs, code);
  } else {
    return code;
  }
 }
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/index.js
@ -0,0 +1,165 @@
 'use strict';
 const colorConvert = require('color-convert');
 const wrapAnsi16 = (fn, offset) => function () {
 	const code = fn.apply(colorConvert, arguments);
 	return `\u001B[${code + offset}m`;
 };
 const wrapAnsi256 = (fn, offset) => function () {
 	const code = fn.apply(colorConvert, arguments);
 	return `\u001B[${38 + offset};5;${code}m`;
 };
 const wrapAnsi16m = (fn, offset) => function () {
 	const rgb = fn.apply(colorConvert, arguments);
 	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
 };
 function assembleStyles() {
 	const codes = new Map();
 	const styles = {
 		modifier: {
 			reset: [0, 0],
 			// 21 isn't widely supported and 22 does the same thing
 			bold: [1, 22],
 			dim: [2, 22],
 			italic: [3, 23],
 			underline: [4, 24],
 			inverse: [7, 27],
 			hidden: [8, 28],
 			strikethrough: [9, 29]
 		},
 		color: {
 			black: [30, 39],
 			red: [31, 39],
 			green: [32, 39],
 			yellow: [33, 39],
 			blue: [34, 39],
 			magenta: [35, 39],
 			cyan: [36, 39],
 			white: [37, 39],
 			gray: [90, 39],
 			// Bright color
 			redBright: [91, 39],
 			greenBright: [92, 39],
 			yellowBright: [93, 39],
 			blueBright: [94, 39],
 			magentaBright: [95, 39],
 			cyanBright: [96, 39],
 			whiteBright: [97, 39]
 		},
 		bgColor: {
 			bgBlack: [40, 49],
 			bgRed: [41, 49],
 			bgGreen: [42, 49],
 			bgYellow: [43, 49],
 			bgBlue: [44, 49],
 			bgMagenta: [45, 49],
 			bgCyan: [46, 49],
 			bgWhite: [47, 49],
 			// Bright color
 			bgBlackBright: [100, 49],
 			bgRedBright: [101, 49],
 			bgGreenBright: [102, 49],
 			bgYellowBright: [103, 49],
 			bgBlueBright: [104, 49],
 			bgMagentaBright: [105, 49],
 			bgCyanBright: [106, 49],
 			bgWhiteBright: [107, 49]
 		}
 	};
 	// Fix humans
 	styles.color.grey = styles.color.gray;
 	for (const groupName of Object.keys(styles)) {
 		const group = styles[groupName];
 		for (const styleName of Object.keys(group)) {
 			const style = group[styleName];
 			styles[styleName] = {
 				open: `\u001B[${style[0]}m`,
 				close: `\u001B[${style[1]}m`
 			};
 			group[styleName] = styles[styleName];
 			codes.set(style[0], style[1]);
 		}
 		Object.defineProperty(styles, groupName, {
 			value: group,
 			enumerable: false
 		});
 		Object.defineProperty(styles, 'codes', {
 			value: codes,
 			enumerable: false
 		});
 	}
 	const ansi2ansi = n => n;
 	const rgb2rgb = (r, g, b) => [r, g, b];
 	styles.color.close = '\u001B[39m';
 	styles.bgColor.close = '\u001B[49m';
 	styles.color.ansi = {
 		ansi: wrapAnsi16(ansi2ansi, 0)
 	};
 	styles.color.ansi256 = {
 		ansi256: wrapAnsi256(ansi2ansi, 0)
 	};
 	styles.color.ansi16m = {
 		rgb: wrapAnsi16m(rgb2rgb, 0)
 	};
 	styles.bgColor.ansi = {
 		ansi: wrapAnsi16(ansi2ansi, 10)
 	};
 	styles.bgColor.ansi256 = {
 		ansi256: wrapAnsi256(ansi2ansi, 10)
 	};
 	styles.bgColor.ansi16m = {
 		rgb: wrapAnsi16m(rgb2rgb, 10)
 	};
 	for (let key of Object.keys(colorConvert)) {
 		if (typeof colorConvert[key] !== 'object') {
 			continue;
 		}
 		const suite = colorConvert[key];
 		if (key === 'ansi16') {
 			key = 'ansi';
 		}
 		if ('ansi16' in suite) {
 			styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
 			styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
 		}
 		if ('ansi256' in suite) {
 			styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
 			styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
 		}
 		if ('rgb' in suite) {
 			styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
 			styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
 		}
 	}
 	return styles;
 }
 // Make the export immutable
 Object.defineProperty(module, 'exports', {
 	enumerable: true,
 	get: assembleStyles
 });
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/license
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/license
@ -0,0 +1,9 @@
 MIT License
 Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/package.json
@ -0,0 +1,56 @@
 {
 	"name": "ansi-styles",
 	"version": "3.2.1",
 	"description": "ANSI escape codes for styling strings in the terminal",
 	"license": "MIT",
 	"repository": "chalk/ansi-styles",
 	"author": {
 		"name": "Sindre Sorhus",
 		"email": "sindresorhus@gmail.com",
 		"url": "sindresorhus.com"
 	},
 	"engines": {
 		"node": ">=4"
 	},
 	"scripts": {
 		"test": "xo && ava",
 		"screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor"
 	},
 	"files": [
 		"index.js"
 	],
 	"keywords": [
 		"ansi",
 		"styles",
 		"color",
 		"colour",
 		"colors",
 		"terminal",
 		"console",
 		"cli",
 		"string",
 		"tty",
 		"escape",
 		"formatting",
 		"rgb",
 		"256",
 		"shell",
 		"xterm",
 		"log",
 		"logging",
 		"command-line",
 		"text"
 	],
 	"dependencies": {
 		"color-convert": "^1.9.0"
 	},
 	"devDependencies": {
 		"ava": "*",
 		"babel-polyfill": "^6.23.0",
 		"svg-term-cli": "^2.1.1",
 		"xo": "*"
 	},
 	"ava": {
 		"require": "babel-polyfill"
 	}
 }
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/readme.md
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/ansi-styles/readme.md
@ -0,0 +1,147 @@
 # ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/ansi-styles)
 > [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
 You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
 <img src="https://cdn.rawgit.com/chalk/ansi-styles/8261697c95bf34b6c7767e2cbe9941a851d59385/screenshot.svg" width="900">
 ## Install
 ```
 $ npm install ansi-styles
 ```
 ## Usage
 ```js
 const style = require('ansi-styles');
 console.log(`${style.green.open}Hello world!${style.green.close}`);
 // Color conversion between 16/256/truecolor
 // NOTE: If conversion goes to 16 colors or 256 colors, the original color
 //       may be degraded to fit that color palette. This means terminals
 //       that do not support 16 million colors will best-match the
 //       original color.
 console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
 console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
 console.log(style.color.ansi16m.hex('#ABCDEF') + 'Hello world!' + style.color.close);
 ```
 ## API
 Each style has an `open` and `close` property.
 ## Styles
 ### Modifiers
 - `reset`
 - `bold`
 - `dim`
 - `italic` *(Not widely supported)*
 - `underline`
 - `inverse`
 - `hidden`
 - `strikethrough` *(Not widely supported)*
 ### Colors
 - `black`
 - `red`
 - `green`
 - `yellow`
 - `blue`
 - `magenta`
 - `cyan`
 - `white`
 - `gray` ("bright black")
 - `redBright`
 - `greenBright`
 - `yellowBright`
 - `blueBright`
 - `magentaBright`
 - `cyanBright`
 - `whiteBright`
 ### Background colors
 - `bgBlack`
 - `bgRed`
 - `bgGreen`
 - `bgYellow`
 - `bgBlue`
 - `bgMagenta`
 - `bgCyan`
 - `bgWhite`
 - `bgBlackBright`
 - `bgRedBright`
 - `bgGreenBright`
 - `bgYellowBright`
 - `bgBlueBright`
 - `bgMagentaBright`
 - `bgCyanBright`
 - `bgWhiteBright`
 ## Advanced usage
 By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
 - `style.modifier`
 - `style.color`
 - `style.bgColor`
 ###### Example
 ```js
 console.log(style.color.green.open);
 ```
 Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
 ###### Example
 ```js
 console.log(style.codes.get(36));
 //=> 39
 ```
 ## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
 `ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
 To use these, call the associated conversion function with the intended output, for example:
 ```js
 style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
 style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
 style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
 style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
 style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
 style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code
 ```
 ## Related
 - [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
 ## Maintainers
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Josh Junon](https://github.com/qix-)
 ## License
 MIT
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/index.js
@ -0,0 +1,228 @@
 'use strict';
 const escapeStringRegexp = require('escape-string-regexp');
 const ansiStyles = require('ansi-styles');
 const stdoutColor = require('supports-color').stdout;
 const template = require('./templates.js');
 const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
 // `supportsColor.level` → `ansiStyles.color[name]` mapping
 const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
 // `color-convert` models to exclude from the Chalk API due to conflicts and such
 const skipModels = new Set(['gray']);
 const styles = Object.create(null);
 function applyOptions(obj, options) {
 	options = options || {};
 	// Detect level if not set manually
 	const scLevel = stdoutColor ? stdoutColor.level : 0;
 	obj.level = options.level === undefined ? scLevel : options.level;
 	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
 }
 function Chalk(options) {
 	// We check for this.template here since calling `chalk.constructor()`
 	// by itself will have a `this` of a previously constructed chalk object
 	if (!this || !(this instanceof Chalk) || this.template) {
 		const chalk = {};
 		applyOptions(chalk, options);
 		chalk.template = function () {
 			const args = [].slice.call(arguments);
 			return chalkTag.apply(null, [chalk.template].concat(args));
 		};
 		Object.setPrototypeOf(chalk, Chalk.prototype);
 		Object.setPrototypeOf(chalk.template, chalk);
 		chalk.template.constructor = Chalk;
 		return chalk.template;
 	}
 	applyOptions(this, options);
 }
 // Use bright blue on Windows as the normal blue color is illegible
 if (isSimpleWindowsTerm) {
 	ansiStyles.blue.open = '\u001B[94m';
 }
 for (const key of Object.keys(ansiStyles)) {
 	ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
 	styles[key] = {
 		get() {
 			const codes = ansiStyles[key];
 			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
 		}
 	};
 }
 styles.visible = {
 	get() {
 		return build.call(this, this._styles || [], true, 'visible');
 	}
 };
 ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
 for (const model of Object.keys(ansiStyles.color.ansi)) {
 	if (skipModels.has(model)) {
 		continue;
 	}
 	styles[model] = {
 		get() {
 			const level = this.level;
 			return function () {
 				const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
 				const codes = {
 					open,
 					close: ansiStyles.color.close,
 					closeRe: ansiStyles.color.closeRe
 				};
 				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
 			};
 		}
 	};
 }
 ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
 for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 	if (skipModels.has(model)) {
 		continue;
 	}
 	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
 	styles[bgModel] = {
 		get() {
 			const level = this.level;
 			return function () {
 				const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
 				const codes = {
 					open,
 					close: ansiStyles.bgColor.close,
 					closeRe: ansiStyles.bgColor.closeRe
 				};
 				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
 			};
 		}
 	};
 }
 const proto = Object.defineProperties(() => {}, styles);
 function build(_styles, _empty, key) {
 	const builder = function () {
 		return applyStyle.apply(builder, arguments);
 	};
 	builder._styles = _styles;
 	builder._empty = _empty;
 	const self = this;
 	Object.defineProperty(builder, 'level', {
 		enumerable: true,
 		get() {
 			return self.level;
 		},
 		set(level) {
 			self.level = level;
 		}
 	});
 	Object.defineProperty(builder, 'enabled', {
 		enumerable: true,
 		get() {
 			return self.enabled;
 		},
 		set(enabled) {
 			self.enabled = enabled;
 		}
 	});
 	// See below for fix regarding invisible grey/dim combination on Windows
 	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
 	// `__proto__` is used because we must return a function, but there is
 	// no way to create a function with a different prototype
 	builder.__proto__ = proto; // eslint-disable-line no-proto
 	return builder;
 }
 function applyStyle() {
 	// Support varags, but simply cast to string in case there's only one arg
 	const args = arguments;
 	const argsLen = args.length;
 	let str = String(arguments[0]);
 	if (argsLen === 0) {
 		return '';
 	}
 	if (argsLen > 1) {
 		// Don't slice `arguments`, it prevents V8 optimizations
 		for (let a = 1; a < argsLen; a++) {
 			str += ' ' + args[a];
 		}
 	}
 	if (!this.enabled || this.level <= 0 || !str) {
 		return this._empty ? '' : str;
 	}
 	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
 	// see https://github.com/chalk/chalk/issues/58
 	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
 	const originalDim = ansiStyles.dim.open;
 	if (isSimpleWindowsTerm && this.hasGrey) {
 		ansiStyles.dim.open = '';
 	}
 	for (const code of this._styles.slice().reverse()) {
 		// Replace any instances already present with a re-opening code
 		// otherwise only the part of the string until said closing code
 		// will be colored, and the rest will simply be 'plain'.
 		str = code.open + str.replace(code.closeRe, code.open) + code.close;
 		// Close the styling before a linebreak and reopen
 		// after next line to fix a bleed issue on macOS
 		// https://github.com/chalk/chalk/pull/92
 		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
 	}
 	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
 	ansiStyles.dim.open = originalDim;
 	return str;
 }
 function chalkTag(chalk, strings) {
 	if (!Array.isArray(strings)) {
 		// If chalk() was called by itself or with a string,
 		// return the string itself as a string.
 		return [].slice.call(arguments, 1).join(' ');
 	}
 	const args = [].slice.call(arguments, 2);
 	const parts = [strings.raw[0]];
 	for (let i = 1; i < strings.length; i++) {
 		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
 		parts.push(String(strings.raw[i]));
 	}
 	return template(chalk, parts.join(''));
 }
 Object.defineProperties(Chalk.prototype, styles);
 module.exports = Chalk(); // eslint-disable-line new-cap
 module.exports.supportsColor = stdoutColor;
 module.exports.default = module.exports; // For TypeScript
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/index.js.flow
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/index.js.flow
@ -0,0 +1,93 @@
 // @flow strict
 type TemplateStringsArray = $ReadOnlyArray<string>;
 export type Level = $Values<{
 	None: 0,
 	Basic: 1,
 	Ansi256: 2,
 	TrueColor: 3
 }>;
 export type ChalkOptions = {|
 	enabled?: boolean,
 	level?: Level
 |};
 export type ColorSupport = {|
 	level: Level,
 	hasBasic: boolean,
 	has256: boolean,
 	has16m: boolean
 |};
 export interface Chalk {
 	(...text: string[]): string,
 	(text: TemplateStringsArray, ...placeholders: string[]): string,
 	constructor(options?: ChalkOptions): Chalk,
 	enabled: boolean,
 	level: Level,
 	rgb(r: number, g: number, b: number): Chalk,
 	hsl(h: number, s: number, l: number): Chalk,
 	hsv(h: number, s: number, v: number): Chalk,
 	hwb(h: number, w: number, b: number): Chalk,
 	bgHex(color: string): Chalk,
 	bgKeyword(color: string): Chalk,
 	bgRgb(r: number, g: number, b: number): Chalk,
 	bgHsl(h: number, s: number, l: number): Chalk,
 	bgHsv(h: number, s: number, v: number): Chalk,
 	bgHwb(h: number, w: number, b: number): Chalk,
 	hex(color: string): Chalk,
 	keyword(color: string): Chalk,
 	+reset: Chalk,
 	+bold: Chalk,
 	+dim: Chalk,
 	+italic: Chalk,
 	+underline: Chalk,
 	+inverse: Chalk,
 	+hidden: Chalk,
 	+strikethrough: Chalk,
 	+visible: Chalk,
 	+black: Chalk,
 	+red: Chalk,
 	+green: Chalk,
 	+yellow: Chalk,
 	+blue: Chalk,
 	+magenta: Chalk,
 	+cyan: Chalk,
 	+white: Chalk,
 	+gray: Chalk,
 	+grey: Chalk,
 	+blackBright: Chalk,
 	+redBright: Chalk,
 	+greenBright: Chalk,
 	+yellowBright: Chalk,
 	+blueBright: Chalk,
 	+magentaBright: Chalk,
 	+cyanBright: Chalk,
 	+whiteBright: Chalk,
 	+bgBlack: Chalk,
 	+bgRed: Chalk,
 	+bgGreen: Chalk,
 	+bgYellow: Chalk,
 	+bgBlue: Chalk,
 	+bgMagenta: Chalk,
 	+bgCyan: Chalk,
 	+bgWhite: Chalk,
 	+bgBlackBright: Chalk,
 	+bgRedBright: Chalk,
 	+bgGreenBright: Chalk,
 	+bgYellowBright: Chalk,
 	+bgBlueBright: Chalk,
 	+bgMagentaBright: Chalk,
 	+bgCyanBright: Chalk,
 	+bgWhiteBrigh: Chalk,
 	supportsColor: ColorSupport
 };
 declare module.exports: Chalk;
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/license
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/license
@ -0,0 +1,9 @@
 MIT License
 Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/package.json
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/package.json
@ -0,0 +1,71 @@
 {
 	"name": "chalk",
 	"version": "2.4.2",
 	"description": "Terminal string styling done right",
 	"license": "MIT",
 	"repository": "chalk/chalk",
 	"engines": {
 		"node": ">=4"
 	},
 	"scripts": {
 		"test": "xo && tsc --project types && flow --max-warnings=0 && nyc ava",
 		"bench": "matcha benchmark.js",
 		"coveralls": "nyc report --reporter=text-lcov | coveralls"
 	},
 	"files": [
 		"index.js",
 		"templates.js",
 		"types/index.d.ts",
 		"index.js.flow"
 	],
 	"keywords": [
 		"color",
 		"colour",
 		"colors",
 		"terminal",
 		"console",
 		"cli",
 		"string",
 		"str",
 		"ansi",
 		"style",
 		"styles",
 		"tty",
 		"formatting",
 		"rgb",
 		"256",
 		"shell",
 		"xterm",
 		"log",
 		"logging",
 		"command-line",
 		"text"
 	],
 	"dependencies": {
 		"ansi-styles": "^3.2.1",
 		"escape-string-regexp": "^1.0.5",
 		"supports-color": "^5.3.0"
 	},
 	"devDependencies": {
 		"ava": "*",
 		"coveralls": "^3.0.0",
 		"execa": "^0.9.0",
 		"flow-bin": "^0.68.0",
 		"import-fresh": "^2.0.0",
 		"matcha": "^0.7.0",
 		"nyc": "^11.0.2",
 		"resolve-from": "^4.0.0",
 		"typescript": "^2.5.3",
 		"xo": "*"
 	},
 	"types": "types/index.d.ts",
 	"xo": {
 		"envs": [
 			"node",
 			"mocha"
 		],
 		"ignores": [
 			"test/_flow.js"
 		]
 	}
 }
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/readme.md
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/readme.md
@ -0,0 +1,314 @@
 <h1 align="center">
 	<br>
 	<br>
 	<img width="320" src="media/logo.svg" alt="Chalk">
 	<br>
 	<br>
 	<br>
 </h1>
 > Terminal string styling done right
 [![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/xojs/xo) [![Mentioned in Awesome Node.js](https://awesome.re/mentioned-badge.svg)](https://github.com/sindresorhus/awesome-nodejs)
 ### [See what's new in Chalk 2](https://github.com/chalk/chalk/releases/tag/v2.0.0)
 <img src="https://cdn.rawgit.com/chalk/ansi-styles/8261697c95bf34b6c7767e2cbe9941a851d59385/screenshot.svg" alt="" width="900">
 ## Highlights
 - Expressive API
 - Highly performant
 - Ability to nest styles
 - [256/Truecolor color support](#256-and-truecolor-color-support)
 - Auto-detects color support
 - Doesn't extend `String.prototype`
 - Clean and focused
 - Actively maintained
 - [Used by ~23,000 packages](https://www.npmjs.com/browse/depended/chalk) as of December 31, 2017
 ## Install
 ```console
 $ npm install chalk
 ```
 <a href="https://www.patreon.com/sindresorhus">
 	<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
 </a>
 ## Usage
 ```js
 const chalk = require('chalk');
 console.log(chalk.blue('Hello world!'));
 ```
 Chalk comes with an easy to use composable API where you just chain and nest the styles you want.
 ```js
 const chalk = require('chalk');
 const log = console.log;
 // Combine styled and normal strings
 log(chalk.blue('Hello') + ' World' + chalk.red('!'));
 // Compose multiple styles using the chainable API
 log(chalk.blue.bgRed.bold('Hello world!'));
 // Pass in multiple arguments
 log(chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz'));
 // Nest styles
 log(chalk.red('Hello', chalk.underline.bgBlue('world') + '!'));
 // Nest styles of the same type even (color, underline, background)
 log(chalk.green(
 	'I am a green line ' +
 	chalk.blue.underline.bold('with a blue substring') +
 	' that becomes green again!'
 ));
 // ES2015 template literal
 log(`
 CPU: ${chalk.red('90%')}
 RAM: ${chalk.green('40%')}
 DISK: ${chalk.yellow('70%')}
 `);
 // ES2015 tagged template literal
 log(chalk`
 CPU: {red ${cpu.totalPercent}%}
 RAM: {green ${ram.used / ram.total * 100}%}
 DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
 `);
 // Use RGB colors in terminal emulators that support it.
 log(chalk.keyword('orange')('Yay for orange colored text!'));
 log(chalk.rgb(123, 45, 67).underline('Underlined reddish color'));
 log(chalk.hex('#DEADED').bold('Bold gray!'));
 ```
 Easily define your own themes:
 ```js
 const chalk = require('chalk');
 const error = chalk.bold.red;
 const warning = chalk.keyword('orange');
 console.log(error('Error!'));
 console.log(warning('Warning!'));
 ```
 Take advantage of console.log [string substitution](https://nodejs.org/docs/latest/api/console.html#console_console_log_data_args):
 ```js
 const name = 'Sindre';
 console.log(chalk.green('Hello %s'), name);
 //=> 'Hello Sindre'
 ```
 ## API
 ### chalk.`<style>[.<style>...](string, [string...])`
 Example: `chalk.red.bold.underline('Hello', 'world');`
 Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
 Multiple arguments will be separated by space.
 ### chalk.enabled
 Color support is automatically detected, as is the level (see `chalk.level`). However, if you'd like to simply enable/disable Chalk, you can do so via the `.enabled` property.
 Chalk is enabled by default unless explicitly disabled via the constructor or `chalk.level` is `0`.
 If you need to change this in a reusable module, create a new instance:
 ```js
 const ctx = new chalk.constructor({enabled: false});
 ```
 ### chalk.level
 Color support is automatically detected, but you can override it by setting the `level` property. You should however only do this in your own code as it applies globally to all Chalk consumers.
 If you need to change this in a reusable module, create a new instance:
 ```js
 const ctx = new chalk.constructor({level: 0});
 ```
 Levels are as follows:
 0. All colors disabled
 1. Basic color support (16 colors)
 2. 256 color support
 3. Truecolor support (16 million colors)
 ### chalk.supportsColor
 Detect whether the terminal [supports color](https://github.com/chalk/supports-color). Used internally and handled for you, but exposed for convenience.
 Can be overridden by the user with the flags `--color` and `--no-color`. For situations where using `--color` is not possible, add the environment variable `FORCE_COLOR=1` to forcefully enable color or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks.
 Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively.
 ## Styles
 ### Modifiers
 - `reset`
 - `bold`
 - `dim`
 - `italic` *(Not widely supported)*
 - `underline`
 - `inverse`
 - `hidden`
 - `strikethrough` *(Not widely supported)*
 - `visible` (Text is emitted only if enabled)
 ### Colors
 - `black`
 - `red`
 - `green`
 - `yellow`
 - `blue` *(On Windows the bright version is used since normal blue is illegible)*
 - `magenta`
 - `cyan`
 - `white`
 - `gray` ("bright black")
 - `redBright`
 - `greenBright`
 - `yellowBright`
 - `blueBright`
 - `magentaBright`
 - `cyanBright`
 - `whiteBright`
 ### Background colors
 - `bgBlack`
 - `bgRed`
 - `bgGreen`
 - `bgYellow`
 - `bgBlue`
 - `bgMagenta`
 - `bgCyan`
 - `bgWhite`
 - `bgBlackBright`
 - `bgRedBright`
 - `bgGreenBright`
 - `bgYellowBright`
 - `bgBlueBright`
 - `bgMagentaBright`
 - `bgCyanBright`
 - `bgWhiteBright`
 ## Tagged template literal
 Chalk can be used as a [tagged template literal](http://exploringjs.com/es6/ch_template-literals.html#_tagged-template-literals).
 ```js
 const chalk = require('chalk');
 const miles = 18;
 const calculateFeet = miles => miles * 5280;
 console.log(chalk`
  There are {bold 5280 feet} in a mile.
  In {bold ${miles} miles}, there are {green.bold ${calculateFeet(miles)} feet}.
 `);
 ```
 Blocks are delimited by an opening curly brace (`{`), a style, some content, and a closing curly brace (`}`).
 Template styles are chained exactly like normal Chalk styles. The following two statements are equivalent:
 ```js
 console.log(chalk.bold.rgb(10, 100, 200)('Hello!'));
 console.log(chalk`{bold.rgb(10,100,200) Hello!}`);
 ```
 Note that function styles (`rgb()`, `hsl()`, `keyword()`, etc.) may not contain spaces between parameters.
 All interpolated values (`` chalk`${foo}` ``) are converted to strings via the `.toString()` method. All curly braces (`{` and `}`) in interpolated value strings are escaped.
 ## 256 and Truecolor color support
 Chalk supports 256 colors and [Truecolor](https://gist.github.com/XVilka/8346728) (16 million colors) on supported terminal apps.
 Colors are downsampled from 16 million RGB values to an ANSI color format that is supported by the terminal emulator (or by specifying `{level: n}` as a Chalk option). For example, Chalk configured to run at level 1 (basic color support) will downsample an RGB value of #FF0000 (red) to 31 (ANSI escape for red).
 Examples:
 - `chalk.hex('#DEADED').underline('Hello, world!')`
 - `chalk.keyword('orange')('Some orange text')`
 - `chalk.rgb(15, 100, 204).inverse('Hello!')`
 Background versions of these models are prefixed with `bg` and the first level of the module capitalized (e.g. `keyword` for foreground colors and `bgKeyword` for background colors).
 - `chalk.bgHex('#DEADED').underline('Hello, world!')`
 - `chalk.bgKeyword('orange')('Some orange text')`
 - `chalk.bgRgb(15, 100, 204).inverse('Hello!')`
 The following color models can be used:
 - [`rgb`](https://en.wikipedia.org/wiki/RGB_color_model) - Example: `chalk.rgb(255, 136, 0).bold('Orange!')`
 - [`hex`](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet) - Example: `chalk.hex('#FF8800').bold('Orange!')`
 - [`keyword`](https://www.w3.org/wiki/CSS/Properties/color/keywords) (CSS keywords) - Example: `chalk.keyword('orange').bold('Orange!')`
 - [`hsl`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsl(32, 100, 50).bold('Orange!')`
 - [`hsv`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsv(32, 100, 100).bold('Orange!')`
 - [`hwb`](https://en.wikipedia.org/wiki/HWB_color_model)  - Example: `chalk.hwb(32, 0, 50).bold('Orange!')`
 - `ansi16`
 - `ansi256`
 ## Windows
 If you're on Windows, do yourself a favor and use [`cmder`](http://cmder.net/) instead of `cmd.exe`.
 ## Origin story
 [colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
 ## Related
 - [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module
 - [ansi-styles](https://github.com/chalk/ansi-styles) - ANSI escape codes for styling strings in the terminal
 - [supports-color](https://github.com/chalk/supports-color) - Detect whether a terminal supports color
 - [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes
 - [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Strip ANSI escape codes from a stream
 - [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
 - [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
 - [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
 - [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes
 - [color-convert](https://github.com/qix-/color-convert) - Converts colors between different models
 - [chalk-animation](https://github.com/bokub/chalk-animation) - Animate strings in the terminal
 - [gradient-string](https://github.com/bokub/gradient-string) - Apply color gradients to strings
 - [chalk-pipe](https://github.com/LitoMore/chalk-pipe) - Create chalk style schemes with simpler style strings
 - [terminal-link](https://github.com/sindresorhus/terminal-link) - Create clickable links in the terminal
 ## Maintainers
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Josh Junon](https://github.com/qix-)
 ## License
 MIT
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/templates.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/templates.js
@ -0,0 +1,128 @@
 'use strict';
 const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
 const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
 const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
 const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
 const ESCAPES = new Map([
 	['n', '\n'],
 	['r', '\r'],
 	['t', '\t'],
 	['b', '\b'],
 	['f', '\f'],
 	['v', '\v'],
 	['0', '\0'],
 	['\\', '\\'],
 	['e', '\u001B'],
 	['a', '\u0007']
 ]);
 function unescape(c) {
 	if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
 		return String.fromCharCode(parseInt(c.slice(1), 16));
 	}
 	return ESCAPES.get(c) || c;
 }
 function parseArguments(name, args) {
 	const results = [];
 	const chunks = args.trim().split(/\s*,\s*/g);
 	let matches;
 	for (const chunk of chunks) {
 		if (!isNaN(chunk)) {
 			results.push(Number(chunk));
 		} else if ((matches = chunk.match(STRING_REGEX))) {
 			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
 		} else {
 			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
 		}
 	}
 	return results;
 }
 function parseStyle(style) {
 	STYLE_REGEX.lastIndex = 0;
 	const results = [];
 	let matches;
 	while ((matches = STYLE_REGEX.exec(style)) !== null) {
 		const name = matches[1];
 		if (matches[2]) {
 			const args = parseArguments(name, matches[2]);
 			results.push([name].concat(args));
 		} else {
 			results.push([name]);
 		}
 	}
 	return results;
 }
 function buildStyle(chalk, styles) {
 	const enabled = {};
 	for (const layer of styles) {
 		for (const style of layer.styles) {
 			enabled[style[0]] = layer.inverse ? null : style.slice(1);
 		}
 	}
 	let current = chalk;
 	for (const styleName of Object.keys(enabled)) {
 		if (Array.isArray(enabled[styleName])) {
 			if (!(styleName in current)) {
 				throw new Error(`Unknown Chalk style: ${styleName}`);
 			}
 			if (enabled[styleName].length > 0) {
 				current = current[styleName].apply(current, enabled[styleName]);
 			} else {
 				current = current[styleName];
 			}
 		}
 	}
 	return current;
 }
 module.exports = (chalk, tmp) => {
 	const styles = [];
 	const chunks = [];
 	let chunk = [];
 	// eslint-disable-next-line max-params
 	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
 		if (escapeChar) {
 			chunk.push(unescape(escapeChar));
 		} else if (style) {
 			const str = chunk.join('');
 			chunk = [];
 			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
 			styles.push({inverse, styles: parseStyle(style)});
 		} else if (close) {
 			if (styles.length === 0) {
 				throw new Error('Found extraneous } in Chalk template literal');
 			}
 			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
 			chunk = [];
 			styles.pop();
 		} else {
 			chunk.push(chr);
 		}
 	});
 	chunks.push(chunk.join(''));
 	if (styles.length > 0) {
 		const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
 		throw new Error(errMsg);
 	}
 	return chunks.join('');
 };
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/types/index.d.ts
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/chalk/types/index.d.ts
@ -0,0 +1,97 @@
 // Type definitions for Chalk
 // Definitions by: Thomas Sauer <https://github.com/t-sauer>
 export const enum Level {
 	None = 0,
 	Basic = 1,
 	Ansi256 = 2,
 	TrueColor = 3
 }
 export interface ChalkOptions {
 	enabled?: boolean;
 	level?: Level;
 }
 export interface ChalkConstructor {
 	new (options?: ChalkOptions): Chalk;
 	(options?: ChalkOptions): Chalk;
 }
 export interface ColorSupport {
 	level: Level;
 	hasBasic: boolean;
 	has256: boolean;
 	has16m: boolean;
 }
 export interface Chalk {
 	(...text: string[]): string;
 	(text: TemplateStringsArray, ...placeholders: string[]): string;
 	constructor: ChalkConstructor;
 	enabled: boolean;
 	level: Level;
 	rgb(r: number, g: number, b: number): this;
 	hsl(h: number, s: number, l: number): this;
 	hsv(h: number, s: number, v: number): this;
 	hwb(h: number, w: number, b: number): this;
 	bgHex(color: string): this;
 	bgKeyword(color: string): this;
 	bgRgb(r: number, g: number, b: number): this;
 	bgHsl(h: number, s: number, l: number): this;
 	bgHsv(h: number, s: number, v: number): this;
 	bgHwb(h: number, w: number, b: number): this;
 	hex(color: string): this;
 	keyword(color: string): this;
 	readonly reset: this;
 	readonly bold: this;
 	readonly dim: this;
 	readonly italic: this;
 	readonly underline: this;
 	readonly inverse: this;
 	readonly hidden: this;
 	readonly strikethrough: this;
 	readonly visible: this;
 	readonly black: this;
 	readonly red: this;
 	readonly green: this;
 	readonly yellow: this;
 	readonly blue: this;
 	readonly magenta: this;
 	readonly cyan: this;
 	readonly white: this;
 	readonly gray: this;
 	readonly grey: this;
 	readonly blackBright: this;
 	readonly redBright: this;
 	readonly greenBright: this;
 	readonly yellowBright: this;
 	readonly blueBright: this;
 	readonly magentaBright: this;
 	readonly cyanBright: this;
 	readonly whiteBright: this;
 	readonly bgBlack: this;
 	readonly bgRed: this;
 	readonly bgGreen: this;
 	readonly bgYellow: this;
 	readonly bgBlue: this;
 	readonly bgMagenta: this;
 	readonly bgCyan: this;
 	readonly bgWhite: this;
 	readonly bgBlackBright: this;
 	readonly bgRedBright: this;
 	readonly bgGreenBright: this;
 	readonly bgYellowBright: this;
 	readonly bgBlueBright: this;
 	readonly bgMagentaBright: this;
 	readonly bgCyanBright: this;
 	readonly bgWhiteBright: this;
 }
 declare const chalk: Chalk & { supportsColor: ColorSupport };
 export default chalk
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/supports-color/browser.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/supports-color/browser.js
@ -0,0 +1,5 @@
 'use strict';
 module.exports = {
 	stdout: false,
 	stderr: false
 };
--- a/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/supports-color/index.js
+++ b/node_modules/ssb-server/node_modules/@babel/highlight/node_modules/supports-color/index.js
@ -0,0 +1,131 @@
 'use strict';
 const os = require('os');
 const hasFlag = require('has-flag');
 const env = process.env;
 let forceColor;
 if (hasFlag('no-color') ||
 	hasFlag('no-colors') ||
 	hasFlag('color=false')) {
 	forceColor = false;
 } else if (hasFlag('color') ||
 	hasFlag('colors') ||
 	hasFlag('color=true') ||
 	hasFlag('color=always')) {
 	forceColor = true;
 }
 if ('FORCE_COLOR' in env) {
 	forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
 }
 function translateLevel(level) {
 	if (level === 0) {
 		return false;
 	}
 	return {
 		level,
 		hasBasic: true,
 		has256: level >= 2,
 		has16m: level >= 3
 	};
 }
 function supportsColor(stream) {
 	if (forceColor === false) {
 		return 0;
 	}
 	if (hasFlag('color=16m') ||
 		hasFlag('color=full') ||
 		hasFlag('color=truecolor')) {
 		return 3;
 	}
 	if (hasFlag('color=256')) {
 		return 2;
 	}
 	if (stream && !stream.isTTY && forceColor !== true) {
 		return 0;
 	}
 	const min = forceColor ? 1 : 0;
 	if (process.platform === 'win32') {
 		// Node.js 7.5.0 is the first version of Node.js to include a patch to
 		// libuv that enables 256 color output on Windows. Anything earlier and it
 		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
 		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
 		// release that supports 256 colors. Windows 10 build 14931 is the first release
 		// that supports 16m/TrueColor.
 		const osRelease = os.release().split('.');
 		if (
 			Number(process.versions.node.split('.')[0]) >= 8 &&
 			Number(osRelease[0]) >= 10 &&
 			Number(osRelease[2]) >= 10586
 		) {
 			return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		}
 		return 1;
 	}
 	if ('CI' in env) {
 		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
 			return 1;
 		}
 		return min;
 	}
 	if ('TEAMCITY_VERSION' in env) {
 		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
 	}
 	if (env.COLORTERM === 'truecolor') {
 		return 3;
 	}
 	if ('TERM_PROGRAM' in env) {
 		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
 		switch (env.TERM_PROGRAM) {
 			case 'iTerm.app':
 				return version >= 3 ? 3 : 2;
 			case 'Apple_Terminal':
 				return 2;
 			// No default
 		}
 	}
 	if (/-256(color)?$/i.test(env.TERM)) {
 		return 2;
 	}
 	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
 		return 1;
 	}
 	if ('COLORTERM' in env) {
 		return 1;
 	}
 	if (env.TERM === 'dumb') {
 		return min;
 	}
 	return min;
 }
 function getSupportLevel(stream) {
 	const level = supportsColor(stream);
 	return translateLevel(level);
 }
 module.exports = {
 	supportsColor: getSupportLevel,
 	stdout: getSupportLevel(process.stdout),
 	stderr: getSupportLevel(process.stderr)
 };
--- a/Show more
+++ b/Show more
		`@ -0,0 +1 @@`
							`open_collective: secure-scuttlebutt-consortium`