Merge-Konflikte gelöst: Remote-Version übernommen

.htaccess

@@ -1,25 +1,76 @@
-Allow from All
-Satisfy Any
-
-# – --------------------------------------------------------------
-# Belässt die Dateien, die sich selten oder gar nicht ändern, für eine bestimmte Zeit im Browser-Cache
-# – --------------------------------------------------------------
-## EXPIRES CACHING ##
-<IfModule mod_expires.c>
-ExpiresActive On
-ExpiresByType text/css "access plus 0 seconds"
-ExpiresByType text/html "access plus 0 seconds"
-ExpiresByType text/x-javascript "access plus 0 seconds"
-ExpiresByType application/json "access plus 0 seconds"
-
-ExpiresDefault "access plus 0 seconds"
+# ============================================================
+# 🌐 Basis-Zugriffskontrolle
+# ============================================================
+<IfModule mod_authz_core.c>
+    Require all granted
+</IfModule>
+<IfModule !mod_authz_core.c>
+    Allow from all
+    Satisfy any
 </IfModule>
-## EXPIRES CACHING ##
 
+# ============================================================
+# 🧭 CACHING & BROWSER PERFORMANCE
+# ============================================================
+<IfModule mod_expires.c>
+    ExpiresActive On
 
-## PHP VALUES ##
+    # 📄 Standard-Gültigkeit: 1 Monat
+    ExpiresDefault "access plus 1 month"
+
+    # 🖼️ Bilder, Fonts, Medien (selten geändert)
+    ExpiresByType image/webp "access plus 1 year"
+    ExpiresByType image/jpeg "access plus 1 year"
+    ExpiresByType image/png "access plus 1 year"
+    ExpiresByType image/gif "access plus 1 year"
+    ExpiresByType font/woff2 "access plus 1 year"
+    ExpiresByType font/woff "access plus 1 year"
+
+    # 🧩 CSS, JS – wird bei Änderungen automatisch neu geladen
+    ExpiresByType text/css "access plus 0 days"
+    ExpiresByType application/javascript "access plus 0 days"
+
+    # 📝 HTML – nie cachen, damit aktuelle Inhalte sofort sichtbar sind
+    ExpiresByType text/html "access plus 0 seconds"
+
+    # 🪄 JSON, API, dynamische Daten – kurz halten
+    ExpiresByType application/json "access plus 0 minutes"
+</IfModule>
+
+# ============================================================
+# ⚡ KOMPRIMIERUNG (Bandbreite sparen)
+# ============================================================
+<IfModule mod_deflate.c>
+    AddOutputFilterByType DEFLATE text/plain
+    AddOutputFilterByType DEFLATE text/html
+    AddOutputFilterByType DEFLATE text/css
+    AddOutputFilterByType DEFLATE text/javascript
+    AddOutputFilterByType DEFLATE application/javascript
+    AddOutputFilterByType DEFLATE application/json
+    AddOutputFilterByType DEFLATE application/xml
+    AddOutputFilterByType DEFLATE font/woff2
+</IfModule>
+
+# ============================================================
+# 🔒 SICHERHEIT (grundlegende Header)
+# ============================================================
+<IfModule mod_headers.c>
+    # Verhindert MIME-Type-Sniffing
+    Header set X-Content-Type-Options "nosniff"
+    # Klickschutz
+    Header set X-Frame-Options "SAMEORIGIN"
+    # Cross-Site-Scripting-Schutz
+    Header set X-XSS-Protection "1; mode=block"
+    # Cache-Kontrolle für HTML (keine veralteten Seiten)
+    <FilesMatch "\.(html|php)$">
+        Header set Cache-Control "no-cache, no-store, must-revalidate"
+    </FilesMatch>
+</IfModule>
+
+# ============================================================
+# 🧮 PHP-EINSTELLUNGEN
+# ============================================================
 php_value upload_max_filesize 100M
 php_value post_max_size 100M
-
-
-
+php_value memory_limit 256M
+php_value max_execution_time 120

gittea.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# ============================================================
+# 🧰 Gitea SSH Fix Script (Version 3)
+# Führt vollständige Reparatur von SSH-Keys, Hooks & Rechten durch
+# ============================================================
+
+set -euo pipefail
+grn='\e[32m'; red='\e[31m'; yel='\e[33m'; nc='\e[0m'
+
+echo -e "${grn}🔧 Starte Gitea SSH-Reparatur...${nc}"
+
+# 1️⃣ Gitea-Binary prüfen
+GITEA_BIN=$(command -v gitea || echo "/usr/local/bin/gitea")
+echo -e "${grn}➡ Verwende Gitea-Binary:${nc} $GITEA_BIN"
+
+# 2️⃣ Gitea stoppen
+echo -e "${yel}⏹ Stoppe Gitea-Service...${nc}"
+systemctl stop gitea || echo -e "${red}⚠️  Konnte Gitea nicht stoppen (evtl. nicht aktiv).${nc}"
+
+# 3️⃣ Hooks & Keys regenerieren (richtig: als Benutzer 'git')
+echo -e "${grn}♻️  Regeneriere Hooks und Keys...${nc}"
+sudo -u git "$GITEA_BIN" --config /etc/gitea/app.ini --work-path /var/lib/gitea admin regenerate hooks
+sudo -u git "$GITEA_BIN" --config /etc/gitea/app.ini --work-path /var/lib/gitea admin regenerate keys
+
+# 4️⃣ Berechtigungen für .ssh korrigieren
+echo -e "${grn}🧱  Setze Berechtigungen für .ssh...${nc}"
+chown -R git:git /home/git/.ssh
+chmod 700 /home/git/.ssh
+chmod 600 /home/git/.ssh/authorized_keys
+
+# 5️⃣ authorized_keys prüfen
+if ! grep -q "command=" /home/git/.ssh/authorized_keys; then
+  echo -e "${yel}⚠️  Kein 'command='-Eintrag gefunden – ergänze Gitea-Zeile...${nc}"
+  FIRST_KEY=$(head -n 1 /home/git/.ssh/authorized_keys | awk '{print $NF}')
+  echo "command=\"$GITEA_BIN --config=/etc/gitea/app.ini serv key-1\",no-port-forwarding,no-agent-forwarding,no-pty ssh-ed25519 $FIRST_KEY" > /home/git/.ssh/authorized_keys
+  chown git:git /home/git/.ssh/authorized_keys
+  chmod 600 /home/git/.ssh/authorized_keys
+else
+  echo -e "${grn}✅  authorized_keys sieht gut aus.${nc}"
+fi
+
+# 6️⃣ Gitea starten
+echo -e "${grn}🚀  Starte Gitea neu...${nc}"
+systemctl start gitea
+
+# 7️⃣ SSH-Test lokal
+echo -e "${yel}🔍  Kurzer SSH-Test (lokal)...${nc}"
+sudo -u git ssh -T git@localhost || true
+
+echo -e "\n${grn}✅  Gitea SSH-Fix abgeschlossen.${nc}"
+echo -e "Teste jetzt bitte extern mit:\n  ssh -T git@illg.me\noder\n  git push"

gulpfile.js

@@ -1,64 +1,47 @@
-// 'use strict';
-var gulp = require('gulp');
-//var sass = require('gulp-sass');
-var sass = require('gulp-sass')(require('sass'));
-var cleanCSS = require('gulp-clean-css');
-var rename = require('gulp-rename');
-var autoprefixer = require('gulp-autoprefixer');
-//var imagemin = require('gulp-imagemin');
-var sourcemaps = require('gulp-sourcemaps');
-//var uglify = require('gulp-uglify');
-//var concat = require('gulp-concat');
-//var minify = require('gulp-minify');
+// ============================================================
+// 🧰 GULP CONFIG – WeihnachtsKalenderMelly
+// Sass-Compiler: moderne Dart-Sass-API (keine Legacy-Warnung)
+// ============================================================
 
+const gulp = require('gulp');
+const dartSass = require('sass');                     // 🟢 offizielles Sass-Paket
+const gulpSass = require('gulp-sass')(dartSass);      // 🟢 moderne API
+const cleanCSS = require('gulp-clean-css');
+const rename = require('gulp-rename');
+const autoprefixer = require('gulp-autoprefixer');
+const sourcemaps = require('gulp-sourcemaps');
 
-// scss kompilieren und in css-datei speichern
-// ------------------------------------------------
+const paths = {
+  sass: {
+    src: 'src/sass/*.sass',
+    dest: 'main/'
+  },
+  js: {
+    src: 'src/js/*.js',
+    dest: 'main/'
+  },
+  images: {
+    src: 'src/images/*',
+    dest: 'media/img'
+  }
+};
+
+// 🎨 Sass → CSS
 gulp.task('sass', () => {
-    return gulp.src('src/sass/*.sass')
+  return gulp.src(paths.sass.src)
     .pipe(sourcemaps.init())
-    .pipe(sass({
-    errLogToConsole: true}).on('error', sass.logError))
-    .pipe(autoprefixer(
-            "last 3 version, >1%"
-        ))
+    .pipe(gulpSass.sync({ indentedSyntax: true }).on('error', gulpSass.logError))
+    .pipe(autoprefixer({ overrideBrowserslist: ['last 3 versions', '>1%'] }))
     .pipe(cleanCSS())
     .pipe(rename('min-style.css'))
     .pipe(sourcemaps.write('../main/'))
-    .pipe(gulp.dest('main/'));
+    .pipe(gulp.dest(paths.sass.dest));
 });
-// Js minifizieren
-// ------------------------------------------------
-gulp.task('min-js', () => {
-     return gulp.src('src/js/*.js')
-    .pipe(sourcemaps.init())
-    .pipe(concat('script.js'))
-//    .pipe(uglify())
-//    .pipe(minify())
-    .pipe(rename({prefix: "min-"}))
-    .pipe(sourcemaps.write('../main/'))
-    .pipe(gulp.dest('main/'));
+
+// 👀 Watcher
+gulp.task('watch', () => {
+  gulp.watch(paths.sass.src, gulp.series('sass'));
 });
-// Jpg Bilder Verkleinern
-// ------------------------------------------------
-gulp.task('min-jpg',  () => {
-    return gulp.src('src/images/*')
-    .pipe(imagemin([
-        imagemin.mozjpeg({
-            quality: 75,
-            progressive: true
-    })]))
-    .pipe(rename({prefix: "min-"}))
-    .pipe(gulp.dest('media/img'))
-});
-// gulp verzeichnisse beobachten
-// ------------------------------------------------
-gulp.task('watch', function() {
-    gulp.series('default');
-    gulp.watch('src/sass/*.sass', gulp.series('sass'));
-//    gulp.watch('src/js/*', //gulp.series('min-js'));
- //  gulp.watch('src/images/*', //gulp.series('min-jpg'));
-});
-// gulp 1mal ausführen mit allen task
-// ------------------------------------------------
-    gulp.task('default', gulp.parallel('sass'));
+
+// 🚀 Default-Task
+gulp.task('default', gulp.series('sass'));

index.php

@@ -43,9 +43,9 @@ if ($tab == "") {$tab = "home";}
 <body>
     
     
-<!--div class="develop">
+<div class="develop">
     <h1>!!! Develop !!!</h1>
-</div-->
+</div>
 
 
 <article>
@@ -55,9 +55,6 @@ if ($tab == "") {$tab = "home";}
 </article>
 
 <footer>
-    <!--img class="bgTree" src="./inc/bg/golden_christmas_tree.png"></img-->
-    
-    
     <img src="./inc/bg/1605110464788.png"></img>
     <a href="?tab=impressum" <?php if ($tab == "impressum")?>>Impressum</a> <span id="footer2">-</span>
     <a href="?tab=datenschutz" <?php if ($tab == "datenschutz")?>>Datenschutz</a> <span id="footer2">-</span>

main/overlayDebug.js

@@ -0,0 +1,53 @@
+<script>
+(function() {
+  const overlay = document.createElement("div");
+  overlay.id = "debug-overlay";
+  Object.assign(overlay.style, {
+    position: "fixed",
+    bottom: "10px",
+    left: "10px",
+    background: "rgba(0,0,0,0.7)",
+    color: "white",
+    fontSize: "12px",
+    fontFamily: "monospace",
+    padding: "8px 10px",
+    borderRadius: "8px",
+    zIndex: "9999",
+    lineHeight: "1.4",
+    pointerEvents: "none",
+    whiteSpace: "nowrap"
+  });
+  document.body.appendChild(overlay);
+
+  function getSample() {
+    // 🎯 Bevorzugt den Textbereich mit ID "txt", sonst das erste <p>
+    return document.querySelector("#txt") || document.querySelector("p");
+  }
+
+  function updateInfo() {
+    const sample = getSample();
+    const computed = sample ? getComputedStyle(sample) : {};
+    const fontSize = computed.fontSize || "unknown";
+    const fontFamily = computed.fontFamily || "unknown";
+    const transform = computed.transform || "none";
+    const transformOrigin = computed.transformOrigin || "center";
+    const metrics = sample ? sample.getBoundingClientRect() : { height: 0 };
+
+    overlay.innerHTML = `
+      <b>📏 Debug Info</b><br>
+      Viewport: ${window.innerWidth}px × ${window.innerHeight}px<br>
+      devicePixelRatio: ${window.devicePixelRatio}<br>
+      Font size (CSS): ${fontSize}<br>
+      Rendered height: ${metrics.height.toFixed(2)}px<br>
+      Font family: ${fontFamily}<br>
+      Transform: <span style="color:${transform !== "none" ? "orange" : "lime"};">${transform}</span><br>
+      Origin: ${transformOrigin}<br>
+      Zoom (approx): ${(100 / window.devicePixelRatio).toFixed(1)}%
+    `;
+  }
+
+  updateInfo();
+  window.addEventListener("resize", updateInfo);
+  window.addEventListener("scroll", updateInfo);
+})();
+</script>

node_modules/.bin/baseline-browser-mapping

@@ -0,0 +1 @@
+../baseline-browser-mapping/dist/cli.js

node_modules/.bin/detect-libc

@@ -0,0 +1 @@
+../detect-libc/bin/detect-libc.js

node_modules/@gulp-sourcemaps/identity-map/package.json

@@ -1,44 +1,28 @@
 {
-  "_from": "@gulp-sourcemaps/identity-map@^2.0.1",
-  "_id": "@gulp-sourcemaps/identity-map@2.0.1",
-  "_inBundle": false,
-  "_integrity": "sha512-Tb+nSISZku+eQ4X1lAkevcQa+jknn/OVUgZ3XCxEKIsLsqYuPoJwJOPQeaOk75X3WPftb29GWY1eqE7GLsXb1Q==",
-  "_location": "/@gulp-sourcemaps/identity-map",
-  "_phantomChildren": {
-    "inherits": "2.0.4",
-    "readable-stream": "2.3.7"
-  },
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@gulp-sourcemaps/identity-map@^2.0.1",
   "name": "@gulp-sourcemaps/identity-map",
-    "escapedName": "@gulp-sourcemaps%2fidentity-map",
-    "scope": "@gulp-sourcemaps",
-    "rawSpec": "^2.0.1",
-    "saveSpec": null,
-    "fetchSpec": "^2.0.1"
-  },
-  "_requiredBy": [
-    "/gulp-sourcemaps"
-  ],
-  "_resolved": "https://registry.npmjs.org/@gulp-sourcemaps/identity-map/-/identity-map-2.0.1.tgz",
-  "_shasum": "a6e8b1abec8f790ec6be2b8c500e6e68037c0019",
-  "_spec": "@gulp-sourcemaps/identity-map@^2.0.1",
-  "_where": "/var/www/html/jason/WeihnachtenMelly/node_modules/gulp-sourcemaps",
-  "author": {
-    "name": "Gulp-sourcemaps Team"
-  },
-  "bugs": {
-    "url": "https://github.com/gulp-sourcemaps/identity-map/issues"
-  },
-  "bundleDependencies": false,
+  "version": "2.0.1",
+  "description": "Gulp plugin for generating an identity sourcemap for a file.",
+  "author": "Gulp-sourcemaps Team",
   "contributors": [
-    {
-      "name": "Blaine Bublitz",
-      "email": "blaine.bublitz@gmail.com"
-    }
+    "Blaine Bublitz <blaine.bublitz@gmail.com>"
   ],
+  "repository": "gulp-sourcemaps/identity-map",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js",
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "nyc mocha --async-only",
+    "coveralls": "nyc report --reporter=text-lcov | coveralls"
+  },
   "dependencies": {
     "acorn": "^6.4.1",
     "normalize-path": "^3.0.0",
@@ -46,8 +30,6 @@
     "source-map": "^0.6.0",
     "through2": "^3.0.1"
   },
-  "deprecated": false,
-  "description": "Gulp plugin for generating an identity sourcemap for a file.",
   "devDependencies": {
     "coveralls": "^3.0.3",
     "eslint": "^5.16.0",
@@ -58,33 +40,10 @@
     "nyc": "^14.1.0",
     "vinyl": "^2.2.0"
   },
-  "engines": {
-    "node": ">= 0.10"
-  },
-  "files": [
-    "LICENSE",
-    "index.js",
-    "lib"
-  ],
-  "homepage": "https://github.com/gulp-sourcemaps/identity-map#readme",
   "keywords": [
     "sourcemap",
     "identity",
     "generate",
     "stream"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "@gulp-sourcemaps/identity-map",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gulp-sourcemaps/identity-map.git"
-  },
-  "scripts": {
-    "coveralls": "nyc report --reporter=text-lcov | coveralls",
-    "lint": "eslint .",
-    "pretest": "npm run lint",
-    "test": "nyc mocha --async-only"
-  },
-  "version": "2.0.1"
+  ]
 }

node_modules/@parcel/watcher-linux-x64-glibc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+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.

node_modules/@parcel/watcher-linux-x64-glibc/README.md

@@ -0,0 +1 @@
+This is the linux-x64-glibc build of @parcel/watcher. See https://github.com/parcel-bundler/watcher for details.

node_modules/@parcel/watcher-linux-x64-glibc/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@parcel/watcher-linux-x64-glibc",
+  "version": "2.5.1",
+  "main": "watcher.node",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/watcher.git"
+  },
+  "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "files": [
+    "watcher.node"
+  ],
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "glibc"
+  ]
+}

node_modules/@parcel/watcher-linux-x64-musl/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+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.

node_modules/@parcel/watcher-linux-x64-musl/README.md

@@ -0,0 +1 @@
+This is the linux-x64-musl build of @parcel/watcher. See https://github.com/parcel-bundler/watcher for details.

node_modules/@parcel/watcher-linux-x64-musl/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@parcel/watcher-linux-x64-musl",
+  "version": "2.5.1",
+  "main": "watcher.node",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/watcher.git"
+  },
+  "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "files": [
+    "watcher.node"
+  ],
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "musl"
+  ]
+}

node_modules/@parcel/watcher/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+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.

node_modules/@parcel/watcher/README.md

@@ -0,0 +1,135 @@
+# @parcel/watcher
+
+A native C++ Node module for querying and subscribing to filesystem events. Used by [Parcel 2](https://github.com/parcel-bundler/parcel).
+
+## Features
+
+- **Watch** - subscribe to realtime recursive directory change notifications when files or directories are created, updated, or deleted.
+- **Query** - performantly query for historical change events in a directory, even when your program is not running.
+- **Native** - implemented in C++ for performance and low-level integration with the operating system.
+- **Cross platform** - includes backends for macOS, Linux, Windows, FreeBSD, and Watchman.
+- **Performant** - events are throttled in C++ so the JavaScript thread is not overwhelmed during large filesystem changes (e.g. `git checkout` or `npm install`).
+- **Scalable** - tens of thousands of files can be watched or queried at once with good performance.
+
+## Example
+
+```javascript
+const watcher = require('@parcel/watcher');
+const path = require('path');
+
+// Subscribe to events
+let subscription = await watcher.subscribe(process.cwd(), (err, events) => {
+  console.log(events);
+});
+
+// later on...
+await subscription.unsubscribe();
+
+// Get events since some saved snapshot in the past
+let snapshotPath = path.join(process.cwd(), 'snapshot.txt');
+let events = await watcher.getEventsSince(process.cwd(), snapshotPath);
+
+// Save a snapshot for later
+await watcher.writeSnapshot(process.cwd(), snapshotPath);
+```
+
+## Watching
+
+`@parcel/watcher` supports subscribing to realtime notifications of changes in a directory. It works recursively, so changes in sub-directories will also be emitted.
+
+Events are throttled and coalesced for performance during large changes like `git checkout` or `npm install`, and a single notification will be emitted with all of the events at the end.
+
+Only one notification will be emitted per file. For example, if a file was both created and updated since the last event, you'll get only a `create` event. If a file is both created and deleted, you will not be notifed of that file. Renames cause two events: a `delete` for the old name, and a `create` for the new name.
+
+```javascript
+let subscription = await watcher.subscribe(process.cwd(), (err, events) => {
+  console.log(events);
+});
+```
+
+Events have two properties:
+
+- `type` - the event type: `create`, `update`, or `delete`.
+- `path` - the absolute path to the file or directory.
+
+To unsubscribe from change notifications, call the `unsubscribe` method on the returned subscription object.
+
+```javascript
+await subscription.unsubscribe();
+```
+
+`@parcel/watcher` has the following watcher backends, listed in priority order:
+
+- [FSEvents](https://developer.apple.com/documentation/coreservices/file_system_events) on macOS
+- [Watchman](https://facebook.github.io/watchman/) if installed
+- [inotify](http://man7.org/linux/man-pages/man7/inotify.7.html) on Linux
+- [ReadDirectoryChangesW](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465%28v%3Dvs.85%29.aspx) on Windows
+- [kqueue](https://man.freebsd.org/cgi/man.cgi?kqueue) on FreeBSD, or as an alternative to FSEvents on macOS
+
+You can specify the exact backend you wish to use by passing the `backend` option. If that backend is not available on the current platform, the default backend will be used instead. See below for the list of backend names that can be passed to the options.
+
+## Querying
+
+`@parcel/watcher` also supports querying for historical changes made in a directory, even when your program is not running. This makes it easy to invalidate a cache and re-build only the files that have changed, for example. It can be **significantly** faster than traversing the entire filesystem to determine what files changed, depending on the platform.
+
+In order to query for historical changes, you first need a previous snapshot to compare to. This can be saved to a file with the `writeSnapshot` function, e.g. just before your program exits.
+
+```javascript
+await watcher.writeSnapshot(dirPath, snapshotPath);
+```
+
+When your program starts up, you can query for changes that have occurred since that snapshot using the `getEventsSince` function.
+
+```javascript
+let events = await watcher.getEventsSince(dirPath, snapshotPath);
+```
+
+The events returned are exactly the same as the events that would be passed to the `subscribe` callback (see above).
+
+`@parcel/watcher` has the following watcher backends, listed in priority order:
+
+- [FSEvents](https://developer.apple.com/documentation/coreservices/file_system_events) on macOS
+- [Watchman](https://facebook.github.io/watchman/) if installed
+- [fts](http://man7.org/linux/man-pages/man3/fts.3.html) (brute force) on Linux and FreeBSD
+- [FindFirstFile](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-findfirstfilea) (brute force) on Windows
+
+The FSEvents (macOS) and Watchman backends are significantly more performant than the brute force backends used by default on Linux and Windows, for example returning results in miliseconds instead of seconds for large directory trees. This is because a background daemon monitoring filesystem changes on those platforms allows us to query cached data rather than traversing the filesystem manually (brute force).
+
+macOS has good performance with FSEvents by default. For the best performance on other platforms, install [Watchman](https://facebook.github.io/watchman/) and it will be used by `@parcel/watcher` automatically.
+
+You can specify the exact backend you wish to use by passing the `backend` option. If that backend is not available on the current platform, the default backend will be used instead. See below for the list of backend names that can be passed to the options.
+
+## Options
+
+All of the APIs in `@parcel/watcher` support the following options, which are passed as an object as the last function argument.
+
+- `ignore` - an array of paths or glob patterns to ignore. uses [`is-glob`](https://github.com/micromatch/is-glob) to distinguish paths from globs. glob patterns are parsed with [`micromatch`](https://github.com/micromatch/micromatch) (see [features](https://github.com/micromatch/micromatch#matching-features)).
+  - paths can be relative or absolute and can either be files or directories. No events will be emitted about these files or directories or their children.
+  - glob patterns match on relative paths from the root that is watched. No events will be emitted for matching paths.
+- `backend` - the name of an explicitly chosen backend to use. Allowed options are `"fs-events"`, `"watchman"`, `"inotify"`, `"kqueue"`, `"windows"`, or `"brute-force"` (only for querying). If the specified backend is not available on the current platform, the default backend will be used instead.
+
+## WASM
+
+The `@parcel/watcher-wasm` package can be used in place of `@parcel/watcher` on unsupported platforms. It relies on the Node `fs` module, so in non-Node environments such as browsers, an `fs` polyfill will be needed.
+
+**Note**: the WASM implementation is significantly less efficient than the native implementations because it must crawl the file system to watch each directory individually. Use the native `@parcel/watcher` package wherever possible.
+
+```js
+import {subscribe} from '@parcel/watcher-wasm';
+
+// Use the module as documented above.
+subscribe(/* ... */);
+```
+
+## Who is using this?
+
+- [Parcel 2](https://parceljs.org/)
+- [VSCode](https://code.visualstudio.com/updates/v1_62#_file-watching-changes)
+- [Tailwind CSS Intellisense](https://github.com/tailwindlabs/tailwindcss-intellisense)
+- [Gatsby Cloud](https://twitter.com/chatsidhartha/status/1435647412828196867)
+- [Nx](https://nx.dev)
+- [Nuxt](https://nuxt.com)
+
+## License
+
+MIT

node_modules/@parcel/watcher/binding.gyp

@@ -0,0 +1,93 @@
+{
+  "targets": [
+    {
+      "target_name": "watcher",
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
+      "sources": [ "src/binding.cc", "src/Watcher.cc", "src/Backend.cc", "src/DirTree.cc", "src/Glob.cc", "src/Debounce.cc" ],
+      "include_dirs" : ["<!(node -p \"require('node-addon-api').include_dir\")"],
+      'cflags!': [ '-fno-exceptions', '-std=c++17' ],
+      'cflags_cc!': [ '-fno-exceptions', '-std=c++17' ],
+      "conditions": [
+        ['OS=="mac"', {
+          "sources": [
+            "src/watchman/BSER.cc",
+            "src/watchman/WatchmanBackend.cc",
+            "src/shared/BruteForceBackend.cc",
+            "src/unix/fts.cc",
+            "src/macos/FSEventsBackend.cc",
+            "src/kqueue/KqueueBackend.cc"
+          ],
+          "link_settings": {
+            "libraries": ["CoreServices.framework"]
+          },
+          "defines": [
+            "WATCHMAN",
+            "BRUTE_FORCE",
+            "FS_EVENTS",
+            "KQUEUE"
+          ],
+          "xcode_settings": {
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES"
+          }
+        }],
+        ['OS=="mac" and target_arch=="arm64"', {
+          "xcode_settings": {
+            "ARCHS": ["arm64"]
+          }
+        }],
+        ['OS=="linux" or OS=="android"', {
+          "sources": [
+            "src/watchman/BSER.cc",
+            "src/watchman/WatchmanBackend.cc",
+            "src/shared/BruteForceBackend.cc",
+            "src/linux/InotifyBackend.cc",
+            "src/unix/legacy.cc"
+          ],
+          "defines": [
+            "WATCHMAN",
+            "INOTIFY",
+            "BRUTE_FORCE"
+          ]
+        }],
+        ['OS=="win"', {
+          "sources": [
+            "src/watchman/BSER.cc",
+            "src/watchman/WatchmanBackend.cc",
+            "src/shared/BruteForceBackend.cc",
+            "src/windows/WindowsBackend.cc",
+            "src/windows/win_utils.cc"
+          ],
+          "defines": [
+            "WATCHMAN",
+            "WINDOWS",
+            "BRUTE_FORCE"
+          ],
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1,  # /EHsc
+              "AdditionalOptions": ['-std:c++17']
+            }
+          }
+        }],
+        ['OS=="freebsd"', {
+          "sources": [
+            "src/watchman/BSER.cc",
+            "src/watchman/WatchmanBackend.cc",
+            "src/shared/BruteForceBackend.cc",
+            "src/unix/fts.cc",
+            "src/kqueue/KqueueBackend.cc"
+          ],
+          "defines": [
+            "WATCHMAN",
+            "BRUTE_FORCE",
+            "KQUEUE"
+          ]
+        }]
+      ]
+    }
+  ],
+  "variables": {
+    "openssl_fips": "",
+    "node_use_dtrace": "false"
+  }
+}

node_modules/@parcel/watcher/index.d.ts

@@ -0,0 +1,49 @@
+declare type FilePath = string;
+declare type GlobPattern = string;
+
+declare namespace ParcelWatcher {
+  export type BackendType = 
+    | 'fs-events'
+    | 'watchman'
+    | 'inotify'
+    | 'windows'
+    | 'brute-force';
+  export type EventType = 'create' | 'update' | 'delete';
+  export interface Options {
+    ignore?: (FilePath|GlobPattern)[];
+    backend?: BackendType;
+  }
+  export type SubscribeCallback = (
+    err: Error | null,
+    events: Event[]
+  ) => unknown;
+  export interface AsyncSubscription {
+    unsubscribe(): Promise<void>;
+  }
+  export interface Event {
+    path: FilePath;
+    type: EventType;
+  }
+  export function getEventsSince(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options
+  ): Promise<Event[]>;
+  export function subscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options
+  ): Promise<AsyncSubscription>;
+  export function unsubscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options
+  ): Promise<void>;
+  export function writeSnapshot(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options
+  ): Promise<FilePath>;
+}
+
+export = ParcelWatcher;

node_modules/@parcel/watcher/index.js

@@ -0,0 +1,41 @@
+const {createWrapper} = require('./wrapper');
+
+let name = `@parcel/watcher-${process.platform}-${process.arch}`;
+if (process.platform === 'linux') {
+  const { MUSL, family } = require('detect-libc');
+  if (family === MUSL) {
+    name += '-musl';
+  } else {
+    name += '-glibc';
+  }
+}
+
+let binding;
+try {
+  binding = require(name);
+} catch (err) {
+  handleError(err);
+  try {
+    binding = require('./build/Release/watcher.node');
+  } catch (err) {
+    handleError(err);
+    try {
+      binding = require('./build/Debug/watcher.node');
+    } catch (err) {
+      handleError(err);
+      throw new Error(`No prebuild or local build of @parcel/watcher found. Tried ${name}. Please ensure it is installed (don't use --no-optional when installing with npm). Otherwise it is possible we don't support your platform yet. If this is the case, please report an issue to https://github.com/parcel-bundler/watcher.`);
+    }
+  }
+}
+
+function handleError(err) {
+  if (err?.code !== 'MODULE_NOT_FOUND') {
+    throw err;
+  }
+}
+
+const wrapper = createWrapper(binding);
+exports.writeSnapshot = wrapper.writeSnapshot;
+exports.getEventsSince = wrapper.getEventsSince;
+exports.subscribe = wrapper.subscribe;
+exports.unsubscribe = wrapper.unsubscribe;

node_modules/@parcel/watcher/index.js.flow

@@ -0,0 +1,48 @@
+// @flow
+declare type FilePath = string;
+declare type GlobPattern = string;
+
+export type BackendType = 
+  | 'fs-events'
+  | 'watchman'
+  | 'inotify'
+  | 'windows'
+  | 'brute-force';
+export type EventType = 'create' | 'update' | 'delete';
+export interface Options {
+  ignore?: Array<FilePath | GlobPattern>,
+  backend?: BackendType
+}
+export type SubscribeCallback = (
+  err: ?Error,
+  events: Array<Event>
+) => mixed;
+export interface AsyncSubscription {
+  unsubscribe(): Promise<void>
+}
+export interface Event {
+  path: FilePath,
+  type: EventType
+}
+declare module.exports: {
+  getEventsSince(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options
+  ): Promise<Array<Event>>,
+  subscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options
+  ): Promise<AsyncSubscription>,
+  unsubscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options
+  ): Promise<void>,
+  writeSnapshot(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options
+  ): Promise<FilePath>
+}

node_modules/@parcel/watcher/node_modules/braces/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+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.

node_modules/@parcel/watcher/node_modules/braces/README.md

@@ -0,0 +1,586 @@
+# braces [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [![NPM version](https://img.shields.io/npm/v/braces.svg?style=flat)](https://www.npmjs.com/package/braces) [![NPM monthly downloads](https://img.shields.io/npm/dm/braces.svg?style=flat)](https://npmjs.org/package/braces) [![NPM total downloads](https://img.shields.io/npm/dt/braces.svg?style=flat)](https://npmjs.org/package/braces) [![Linux Build Status](https://img.shields.io/travis/micromatch/braces.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/braces)
+
+> Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save braces
+```
+
+## v3.0.0 Released!!
+
+See the [changelog](CHANGELOG.md) for details.
+
+## Why use braces?
+
+Brace patterns make globs more powerful by adding the ability to match specific ranges and sequences of characters.
+
+- **Accurate** - complete support for the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/) specification (passes all of the Bash braces tests)
+- **[fast and performant](#benchmarks)** - Starts fast, runs fast and [scales well](#performance) as patterns increase in complexity.
+- **Organized code base** - The parser and compiler are easy to maintain and update when edge cases crop up.
+- **Well-tested** - Thousands of test assertions, and passes all of the Bash, minimatch, and [brace-expansion](https://github.com/juliangruber/brace-expansion) unit tests (as of the date this was written).
+- **Safer** - You shouldn't have to worry about users defining aggressive or malicious brace patterns that can break your application. Braces takes measures to prevent malicious regex that can be used for DDoS attacks (see [catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html)).
+- [Supports lists](#lists) - (aka "sets") `a/{b,c}/d` => `['a/b/d', 'a/c/d']`
+- [Supports sequences](#sequences) - (aka "ranges") `{01..03}` => `['01', '02', '03']`
+- [Supports steps](#steps) - (aka "increments") `{2..10..2}` => `['2', '4', '6', '8', '10']`
+- [Supports escaping](#escaping) - To prevent evaluation of special characters.
+
+## Usage
+
+The main export is a function that takes one or more brace `patterns` and `options`.
+
+```js
+const braces = require('braces');
+// braces(patterns[, options]);
+
+console.log(braces(['{01..05}', '{a..e}']));
+//=> ['(0[1-5])', '([a-e])']
+
+console.log(braces(['{01..05}', '{a..e}'], { expand: true }));
+//=> ['01', '02', '03', '04', '05', 'a', 'b', 'c', 'd', 'e']
+```
+
+### Brace Expansion vs. Compilation
+
+By default, brace patterns are compiled into strings that are optimized for creating regular expressions and matching.
+
+**Compiled**
+
+```js
+console.log(braces('a/{x,y,z}/b'));
+//=> ['a/(x|y|z)/b']
+console.log(braces(['a/{01..20}/b', 'a/{1..5}/b']));
+//=> [ 'a/(0[1-9]|1[0-9]|20)/b', 'a/([1-5])/b' ]
+```
+
+**Expanded**
+
+Enable brace expansion by setting the `expand` option to true, or by using [braces.expand()](#expand) (returns an array similar to what you'd expect from Bash, or `echo {1..5}`, or [minimatch](https://github.com/isaacs/minimatch)):
+
+```js
+console.log(braces('a/{x,y,z}/b', { expand: true }));
+//=> ['a/x/b', 'a/y/b', 'a/z/b']
+
+console.log(braces.expand('{01..10}'));
+//=> ['01','02','03','04','05','06','07','08','09','10']
+```
+
+### Lists
+
+Expand lists (like Bash "sets"):
+
+```js
+console.log(braces('a/{foo,bar,baz}/*.js'));
+//=> ['a/(foo|bar|baz)/*.js']
+
+console.log(braces.expand('a/{foo,bar,baz}/*.js'));
+//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js']
+```
+
+### Sequences
+
+Expand ranges of characters (like Bash "sequences"):
+
+```js
+console.log(braces.expand('{1..3}')); // ['1', '2', '3']
+console.log(braces.expand('a/{1..3}/b')); // ['a/1/b', 'a/2/b', 'a/3/b']
+console.log(braces('{a..c}', { expand: true })); // ['a', 'b', 'c']
+console.log(braces('foo/{a..c}', { expand: true })); // ['foo/a', 'foo/b', 'foo/c']
+
+// supports zero-padded ranges
+console.log(braces('a/{01..03}/b')); //=> ['a/(0[1-3])/b']
+console.log(braces('a/{001..300}/b')); //=> ['a/(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)/b']
+```
+
+See [fill-range](https://github.com/jonschlinkert/fill-range) for all available range-expansion options.
+
+### Steppped ranges
+
+Steps, or increments, may be used with ranges:
+
+```js
+console.log(braces.expand('{2..10..2}'));
+//=> ['2', '4', '6', '8', '10']
+
+console.log(braces('{2..10..2}'));
+//=> ['(2|4|6|8|10)']
+```
+
+When the [.optimize](#optimize) method is used, or [options.optimize](#optionsoptimize) is set to true, sequences are passed to [to-regex-range](https://github.com/jonschlinkert/to-regex-range) for expansion.
+
+### Nesting
+
+Brace patterns may be nested. The results of each expanded string are not sorted, and left to right order is preserved.
+
+**"Expanded" braces**
+
+```js
+console.log(braces.expand('a{b,c,/{x,y}}/e'));
+//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e']
+
+console.log(braces.expand('a/{x,{1..5},y}/c'));
+//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c']
+```
+
+**"Optimized" braces**
+
+```js
+console.log(braces('a{b,c,/{x,y}}/e'));
+//=> ['a(b|c|/(x|y))/e']
+
+console.log(braces('a/{x,{1..5},y}/c'));
+//=> ['a/(x|([1-5])|y)/c']
+```
+
+### Escaping
+
+**Escaping braces**
+
+A brace pattern will not be expanded or evaluted if _either the opening or closing brace is escaped_:
+
+```js
+console.log(braces.expand('a\\{d,c,b}e'));
+//=> ['a{d,c,b}e']
+
+console.log(braces.expand('a{d,c,b\\}e'));
+//=> ['a{d,c,b}e']
+```
+
+**Escaping commas**
+
+Commas inside braces may also be escaped:
+
+```js
+console.log(braces.expand('a{b\\,c}d'));
+//=> ['a{b,c}d']
+
+console.log(braces.expand('a{d\\,c,b}e'));
+//=> ['ad,ce', 'abe']
+```
+
+**Single items**
+
+Following bash conventions, a brace pattern is also not expanded when it contains a single character:
+
+```js
+console.log(braces.expand('a{b}c'));
+//=> ['a{b}c']
+```
+
+## Options
+
+### options.maxLength
+
+**Type**: `Number`
+
+**Default**: `10,000`
+
+**Description**: Limit the length of the input string. Useful when the input string is generated or your application allows users to pass a string, et cetera.
+
+```js
+console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error
+```
+
+### options.expand
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Generate an "expanded" brace pattern (alternatively you can use the `braces.expand()` method, which does the same thing).
+
+```js
+console.log(braces('a/{b,c}/d', { expand: true }));
+//=> [ 'a/b/d', 'a/c/d' ]
+```
+
+### options.nodupes
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Remove duplicates from the returned array.
+
+### options.rangeLimit
+
+**Type**: `Number`
+
+**Default**: `1000`
+
+**Description**: To prevent malicious patterns from being passed by users, an error is thrown when `braces.expand()` is used or `options.expand` is true and the generated range will exceed the `rangeLimit`.
+
+You can customize `options.rangeLimit` or set it to `Inifinity` to disable this altogether.
+
+**Examples**
+
+```js
+// pattern exceeds the "rangeLimit", so it's optimized automatically
+console.log(braces.expand('{1..1000}'));
+//=> ['([1-9]|[1-9][0-9]{1,2}|1000)']
+
+// pattern does not exceed "rangeLimit", so it's NOT optimized
+console.log(braces.expand('{1..100}'));
+//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100']
+```
+
+### options.transform
+
+**Type**: `Function`
+
+**Default**: `undefined`
+
+**Description**: Customize range expansion.
+
+**Example: Transforming non-numeric values**
+
+```js
+const alpha = braces.expand('x/{a..e}/y', {
+  transform(value, index) {
+    // When non-numeric values are passed, "value" is a character code.
+    return 'foo/' + String.fromCharCode(value) + '-' + index;
+  },
+});
+console.log(alpha);
+//=> [ 'x/foo/a-0/y', 'x/foo/b-1/y', 'x/foo/c-2/y', 'x/foo/d-3/y', 'x/foo/e-4/y' ]
+```
+
+**Example: Transforming numeric values**
+
+```js
+const numeric = braces.expand('{1..5}', {
+  transform(value) {
+    // when numeric values are passed, "value" is a number
+    return 'foo/' + value * 2;
+  },
+});
+console.log(numeric);
+//=> [ 'foo/2', 'foo/4', 'foo/6', 'foo/8', 'foo/10' ]
+```
+
+### options.quantifiers
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. For example, `a{1,3}` will match the letter `a` one to three times.
+
+Unfortunately, regex quantifiers happen to share the same syntax as [Bash lists](#lists)
+
+The `quantifiers` option tells braces to detect when [regex quantifiers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#quantifiers) are defined in the given pattern, and not to try to expand them as lists.
+
+**Examples**
+
+```js
+const braces = require('braces');
+console.log(braces('a/b{1,3}/{x,y,z}'));
+//=> [ 'a/b(1|3)/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true }));
+//=> [ 'a/b{1,3}/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', { quantifiers: true, expand: true }));
+//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ]
+```
+
+### options.keepEscaping
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Do not strip backslashes that were used for escaping from the result.
+
+## What is "brace expansion"?
+
+Brace expansion is a type of parameter expansion that was made popular by unix shells for generating lists of strings, as well as regex-like matching when used alongside wildcards (globs).
+
+In addition to "expansion", braces are also used for matching. In other words:
+
+- [brace expansion](#brace-expansion) is for generating new lists
+- [brace matching](#brace-matching) is for filtering existing lists
+
+<details>
+<summary><strong>More about brace expansion</strong> (click to expand)</summary>
+
+There are two main types of brace expansion:
+
+1. **lists**: which are defined using comma-separated values inside curly braces: `{a,b,c}`
+2. **sequences**: which are defined using a starting value and an ending value, separated by two dots: `a{1..3}b`. Optionally, a third argument may be passed to define a "step" or increment to use: `a{1..100..10}b`. These are also sometimes referred to as "ranges".
+
+Here are some example brace patterns to illustrate how they work:
+
+**Sets**
+
+```
+{a,b,c}       => a b c
+{a,b,c}{1,2}  => a1 a2 b1 b2 c1 c2
+```
+
+**Sequences**
+
+```
+{1..9}        => 1 2 3 4 5 6 7 8 9
+{4..-4}       => 4 3 2 1 0 -1 -2 -3 -4
+{1..20..3}    => 1 4 7 10 13 16 19
+{a..j}        => a b c d e f g h i j
+{j..a}        => j i h g f e d c b a
+{a..z..3}     => a d g j m p s v y
+```
+
+**Combination**
+
+Sets and sequences can be mixed together or used along with any other strings.
+
+```
+{a,b,c}{1..3}   => a1 a2 a3 b1 b2 b3 c1 c2 c3
+foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar
+```
+
+The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases.
+
+## Brace matching
+
+In addition to _expansion_, brace patterns are also useful for performing regular-expression-like matching.
+
+For example, the pattern `foo/{1..3}/bar` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+```
+
+But not:
+
+```
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+Braces can also be combined with [glob patterns](https://github.com/jonschlinkert/micromatch) to perform more advanced wildcard matching. For example, the pattern `*/{1..3}/*` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+## Brace matching pitfalls
+
+Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of.
+
+### tldr
+
+**"brace bombs"**
+
+- brace expansion can eat up a huge amount of processing resources
+- as brace patterns increase _linearly in size_, the system resources required to expand the pattern increase exponentially
+- users can accidentally (or intentially) exhaust your system's resources resulting in the equivalent of a DoS attack (bonus: no programming knowledge is required!)
+
+For a more detailed explanation with examples, see the [geometric complexity](#geometric-complexity) section.
+
+### The solution
+
+Jump to the [performance section](#performance) to see how Braces solves this problem in comparison to other libraries.
+
+### Geometric complexity
+
+At minimum, brace patterns with sets limited to two elements have quadradic or `O(n^2)` complexity. But the complexity of the algorithm increases exponentially as the number of sets, _and elements per set_, increases, which is `O(n^c)`.
+
+For example, the following sets demonstrate quadratic (`O(n^2)`) complexity:
+
+```
+{1,2}{3,4}      => (2X2)    => 13 14 23 24
+{1,2}{3,4}{5,6} => (2X2X2)  => 135 136 145 146 235 236 245 246
+```
+
+But add an element to a set, and we get a n-fold Cartesian product with `O(n^c)` complexity:
+
+```
+{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248
+                                    249 257 258 259 267 268 269 347 348 349 357
+                                    358 359 367 368 369
+```
+
+Now, imagine how this complexity grows given that each element is a n-tuple:
+
+```
+{1..100}{1..100}         => (100X100)     => 10,000 elements (38.4 kB)
+{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB)
+```
+
+Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control.
+
+**More information**
+
+Interested in learning more about brace expansion?
+
+- [linuxjournal/bash-brace-expansion](http://www.linuxjournal.com/content/bash-brace-expansion)
+- [rosettacode/Brace_expansion](https://rosettacode.org/wiki/Brace_expansion)
+- [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+
+</details>
+
+## Performance
+
+Braces is not only screaming fast, it's also more accurate the other brace expansion libraries.
+
+### Better algorithms
+
+Fortunately there is a solution to the ["brace bomb" problem](#brace-matching-pitfalls): _don't expand brace patterns into an array when they're used for matching_.
+
+Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently.
+
+**The proof is in the numbers**
+
+Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using `braces()` and `minimatch.braceExpand()`, respectively.
+
+| **Pattern**                 | **braces**          | **[minimatch][]**            |
+| --------------------------- | ------------------- | ---------------------------- |
+| `{1..9007199254740991}`[^1] | `298 B` (5ms 459μs) | N/A (freezes)                |
+| `{1..1000000000000000}`     | `41 B` (1ms 15μs)   | N/A (freezes)                |
+| `{1..100000000000000}`      | `40 B` (890μs)      | N/A (freezes)                |
+| `{1..10000000000000}`       | `39 B` (2ms 49μs)   | N/A (freezes)                |
+| `{1..1000000000000}`        | `38 B` (608μs)      | N/A (freezes)                |
+| `{1..100000000000}`         | `37 B` (397μs)      | N/A (freezes)                |
+| `{1..10000000000}`          | `35 B` (983μs)      | N/A (freezes)                |
+| `{1..1000000000}`           | `34 B` (798μs)      | N/A (freezes)                |
+| `{1..100000000}`            | `33 B` (733μs)      | N/A (freezes)                |
+| `{1..10000000}`             | `32 B` (5ms 632μs)  | `78.89 MB` (16s 388ms 569μs) |
+| `{1..1000000}`              | `31 B` (1ms 381μs)  | `6.89 MB` (1s 496ms 887μs)   |
+| `{1..100000}`               | `30 B` (950μs)      | `588.89 kB` (146ms 921μs)    |
+| `{1..10000}`                | `29 B` (1ms 114μs)  | `48.89 kB` (14ms 187μs)      |
+| `{1..1000}`                 | `28 B` (760μs)      | `3.89 kB` (1ms 453μs)        |
+| `{1..100}`                  | `22 B` (345μs)      | `291 B` (196μs)              |
+| `{1..10}`                   | `10 B` (533μs)      | `20 B` (37μs)                |
+| `{1..3}`                    | `7 B` (190μs)       | `5 B` (27μs)                 |
+
+### Faster algorithms
+
+When you need expansion, braces is still much faster.
+
+_(the following results were generated using `braces.expand()` and `minimatch.braceExpand()`, respectively)_
+
+| **Pattern**     | **braces**                  | **[minimatch][]**            |
+| --------------- | --------------------------- | ---------------------------- |
+| `{1..10000000}` | `78.89 MB` (2s 698ms 642μs) | `78.89 MB` (18s 601ms 974μs) |
+| `{1..1000000}`  | `6.89 MB` (458ms 576μs)     | `6.89 MB` (1s 491ms 621μs)   |
+| `{1..100000}`   | `588.89 kB` (20ms 728μs)    | `588.89 kB` (156ms 919μs)    |
+| `{1..10000}`    | `48.89 kB` (2ms 202μs)      | `48.89 kB` (13ms 641μs)      |
+| `{1..1000}`     | `3.89 kB` (1ms 796μs)       | `3.89 kB` (1ms 958μs)        |
+| `{1..100}`      | `291 B` (424μs)             | `291 B` (211μs)              |
+| `{1..10}`       | `20 B` (487μs)              | `20 B` (72μs)                |
+| `{1..3}`        | `5 B` (166μs)               | `5 B` (27μs)                 |
+
+If you'd like to run these comparisons yourself, see [test/support/generate.js](test/support/generate.js).
+
+## Benchmarks
+
+### Running benchmarks
+
+Install dev dependencies:
+
+```bash
+npm i -d && npm benchmark
+```
+
+### Latest results
+
+Braces is more accurate, without sacrificing performance.
+
+```bash
+● expand - range (expanded)
+     braces x 53,167 ops/sec ±0.12% (102 runs sampled)
+  minimatch x 11,378 ops/sec ±0.10% (102 runs sampled)
+● expand - range (optimized for regex)
+     braces x 373,442 ops/sec ±0.04% (100 runs sampled)
+  minimatch x 3,262 ops/sec ±0.18% (100 runs sampled)
+● expand - nested ranges (expanded)
+     braces x 33,921 ops/sec ±0.09% (99 runs sampled)
+  minimatch x 10,855 ops/sec ±0.28% (100 runs sampled)
+● expand - nested ranges (optimized for regex)
+     braces x 287,479 ops/sec ±0.52% (98 runs sampled)
+  minimatch x 3,219 ops/sec ±0.28% (101 runs sampled)
+● expand - set (expanded)
+     braces x 238,243 ops/sec ±0.19% (97 runs sampled)
+  minimatch x 538,268 ops/sec ±0.31% (96 runs sampled)
+● expand - set (optimized for regex)
+     braces x 321,844 ops/sec ±0.10% (97 runs sampled)
+  minimatch x 140,600 ops/sec ±0.15% (100 runs sampled)
+● expand - nested sets (expanded)
+     braces x 165,371 ops/sec ±0.42% (96 runs sampled)
+  minimatch x 337,720 ops/sec ±0.28% (100 runs sampled)
+● expand - nested sets (optimized for regex)
+     braces x 242,948 ops/sec ±0.12% (99 runs sampled)
+  minimatch x 87,403 ops/sec ±0.79% (96 runs sampled)
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Contributors
+
+| **Commits** | **Contributor**                                               |
+| ----------- | ------------------------------------------------------------- |
+| 197         | [jonschlinkert](https://github.com/jonschlinkert)             |
+| 4           | [doowb](https://github.com/doowb)                             |
+| 1           | [es128](https://github.com/es128)                             |
+| 1           | [eush77](https://github.com/eush77)                           |
+| 1           | [hemanth](https://github.com/hemanth)                         |
+| 1           | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |
+
+### Author
+
+**Jon Schlinkert**
+
+- [GitHub Profile](https://github.com/jonschlinkert)
+- [Twitter Profile](https://twitter.com/jonschlinkert)
+- [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+---
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._

node_modules/@parcel/watcher/node_modules/braces/index.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const stringify = require('./lib/stringify');
+const compile = require('./lib/compile');
+const expand = require('./lib/expand');
+const parse = require('./lib/parse');
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces = (input, options = {}) => {
+  let output = [];
+
+  if (Array.isArray(input)) {
+    for (const pattern of input) {
+      const result = braces.create(pattern, options);
+      if (Array.isArray(result)) {
+        output.push(...result);
+      } else {
+        output.push(result);
+      }
+    }
+  } else {
+    output = [].concat(braces.create(input, options));
+  }
+
+  if (options && options.expand === true && options.nodupes === true) {
+    output = [...new Set(output)];
+  }
+  return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces.parse = (input, options = {}) => parse(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.stringify = (input, options = {}) => {
+  if (typeof input === 'string') {
+    return stringify(braces.parse(input, options), options);
+  }
+  return stringify(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.compile = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces.parse(input, options);
+  }
+  return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.expand = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces.parse(input, options);
+  }
+
+  let result = expand(input, options);
+
+  // filter out empty strings if specified
+  if (options.noempty === true) {
+    result = result.filter(Boolean);
+  }
+
+  // filter out duplicates if specified
+  if (options.nodupes === true) {
+    result = [...new Set(result)];
+  }
+
+  return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.create = (input, options = {}) => {
+  if (input === '' || input.length < 3) {
+    return [input];
+  }
+
+  return options.expand !== true
+    ? braces.compile(input, options)
+    : braces.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+module.exports = braces;

node_modules/@parcel/watcher/node_modules/braces/lib/compile.js

@@ -4,30 +4,32 @@ const fill = require('fill-range');
 const utils = require('./utils');
 
 const compile = (ast, options = {}) => {
-  let walk = (node, parent = {}) => {
-    let invalidBlock = utils.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let invalid = invalidBlock === true || invalidNode === true;
-    let prefix = options.escapeInvalid === true ? '\\' : '';
+  const walk = (node, parent = {}) => {
+    const invalidBlock = utils.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+    const invalid = invalidBlock === true || invalidNode === true;
+    const prefix = options.escapeInvalid === true ? '\\' : '';
     let output = '';
 
     if (node.isOpen === true) {
       return prefix + node.value;
     }
+
     if (node.isClose === true) {
+      console.log('node.isClose', prefix, node.value);
       return prefix + node.value;
     }
 
     if (node.type === 'open') {
-      return invalid ? (prefix + node.value) : '(';
+      return invalid ? prefix + node.value : '(';
     }
 
     if (node.type === 'close') {
-      return invalid ? (prefix + node.value) : ')';
+      return invalid ? prefix + node.value : ')';
     }
 
     if (node.type === 'comma') {
-      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';
     }
 
     if (node.value) {
@@ -35,8 +37,8 @@ const compile = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
-      let range = fill(...args, { ...options, wrap: false, toRegex: true });
+      const args = utils.reduce(node.nodes);
+      const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
 
       if (range.length !== 0) {
         return args.length > 1 && range.length > 1 ? `(${range})` : range;
@@ -44,10 +46,11 @@ const compile = (ast, options = {}) => {
     }
 
     if (node.nodes) {
-      for (let child of node.nodes) {
+      for (const child of node.nodes) {
         output += walk(child, node);
       }
     }
+
     return output;
   };
 

node_modules/@parcel/watcher/node_modules/braces/lib/constants.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = {
-  MAX_LENGTH: 1024 * 64,
+  MAX_LENGTH: 10000,
 
   // Digits
   CHAR_0: '0', /* 0 */

node_modules/@parcel/watcher/node_modules/braces/lib/expand.js

@@ -5,7 +5,7 @@ const stringify = require('./stringify');
 const utils = require('./utils');
 
 const append = (queue = '', stash = '', enclose = false) => {
-  let result = [];
+  const result = [];
 
   queue = [].concat(queue);
   stash = [].concat(stash);
@@ -15,15 +15,15 @@ const append = (queue = '', stash = '', enclose = false) => {
     return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
 
-  for (let item of queue) {
+  for (const item of queue) {
     if (Array.isArray(item)) {
-      for (let value of item) {
+      for (const value of item) {
         result.push(append(value, stash, enclose));
       }
     } else {
       for (let ele of stash) {
         if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
-        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
       }
     }
   }
@@ -31,9 +31,9 @@ const append = (queue = '', stash = '', enclose = false) => {
 };
 
 const expand = (ast, options = {}) => {
-  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
 
-  let walk = (node, parent = {}) => {
+  const walk = (node, parent = {}) => {
     node.queue = [];
 
     let p = parent;
@@ -55,7 +55,7 @@ const expand = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
+      const args = utils.reduce(node.nodes);
 
       if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
         throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
@@ -71,7 +71,7 @@ const expand = (ast, options = {}) => {
       return;
     }
 
-    let enclose = utils.encloseBrace(node);
+    const enclose = utils.encloseBrace(node);
     let queue = node.queue;
     let block = node;
 
@@ -81,7 +81,7 @@ const expand = (ast, options = {}) => {
     }
 
     for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i];
+      const child = node.nodes[i];
 
       if (child.type === 'comma' && node.type === 'brace') {
         if (i === 1) queue.push('');

node_modules/@parcel/watcher/node_modules/braces/lib/parse.js

@@ -33,22 +33,21 @@ const parse = (input, options = {}) => {
     throw new TypeError('Expected a string');
   }
 
-  let opts = options || {};
-  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  const opts = options || {};
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
   if (input.length > max) {
     throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
   }
 
-  let ast = { type: 'root', input, nodes: [] };
-  let stack = [ast];
+  const ast = { type: 'root', input, nodes: [] };
+  const stack = [ast];
   let block = ast;
   let prev = ast;
   let brackets = 0;
-  let length = input.length;
+  const length = input.length;
   let index = 0;
   let depth = 0;
   let value;
-  let memo = {};
 
   /**
    * Helpers
@@ -111,7 +110,6 @@ const parse = (input, options = {}) => {
     if (value === CHAR_LEFT_SQUARE_BRACKET) {
       brackets++;
 
-      let closed = true;
       let next;
 
       while (index < length && (next = advance())) {
@@ -167,7 +165,7 @@ const parse = (input, options = {}) => {
      */
 
     if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
-      let open = value;
+      const open = value;
       let next;
 
       if (options.keepQuotes !== true) {
@@ -199,8 +197,8 @@ const parse = (input, options = {}) => {
     if (value === CHAR_LEFT_CURLY_BRACE) {
       depth++;
 
-      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
-      let brace = {
+      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      const brace = {
         type: 'brace',
         open: true,
         close: false,
@@ -227,7 +225,7 @@ const parse = (input, options = {}) => {
         continue;
       }
 
-      let type = 'close';
+      const type = 'close';
       block = stack.pop();
       block.close = true;
 
@@ -245,7 +243,7 @@ const parse = (input, options = {}) => {
     if (value === CHAR_COMMA && depth > 0) {
       if (block.ranges > 0) {
         block.ranges = 0;
-        let open = block.nodes.shift();
+        const open = block.nodes.shift();
         block.nodes = [open, { type: 'text', value: stringify(block) }];
       }
 
@@ -259,7 +257,7 @@ const parse = (input, options = {}) => {
      */
 
     if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
-      let siblings = block.nodes;
+      const siblings = block.nodes;
 
       if (depth === 0 || siblings.length === 0) {
         push({ type: 'text', value });
@@ -286,7 +284,7 @@ const parse = (input, options = {}) => {
       if (prev.type === 'range') {
         siblings.pop();
 
-        let before = siblings[siblings.length - 1];
+        const before = siblings[siblings.length - 1];
         before.value += prev.value + value;
         prev = before;
         block.ranges--;
@@ -319,8 +317,8 @@ const parse = (input, options = {}) => {
       });
 
       // get the location of the block on parent.nodes (block's siblings)
-      let parent = stack[stack.length - 1];
-      let index = parent.nodes.indexOf(block);
+      const parent = stack[stack.length - 1];
+      const index = parent.nodes.indexOf(block);
       // replace the (invalid) block with it's nodes
       parent.nodes.splice(index, 1, ...block.nodes);
     }

node_modules/@parcel/watcher/node_modules/braces/lib/stringify.js

@@ -3,9 +3,9 @@
 const utils = require('./utils');
 
 module.exports = (ast, options = {}) => {
-  let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+  const stringify = (node, parent = {}) => {
+    const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
     let output = '';
 
     if (node.value) {
@@ -20,7 +20,7 @@ module.exports = (ast, options = {}) => {
     }
 
     if (node.nodes) {
-      for (let child of node.nodes) {
+      for (const child of node.nodes) {
         output += stringify(child);
       }
     }

node_modules/@parcel/watcher/node_modules/braces/lib/utils.js

@@ -0,0 +1,122 @@
+'use strict';
+
+exports.isInteger = num => {
+  if (typeof num === 'number') {
+    return Number.isInteger(num);
+  }
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isInteger(Number(num));
+  }
+  return false;
+};
+
+/**
+ * Find a node of the given type
+ */
+
+exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+/**
+ * Find a node of the given type
+ */
+
+exports.exceedsLimit = (min, max, step = 1, limit) => {
+  if (limit === false) return false;
+  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+};
+
+/**
+ * Escape the given node with '\\' before node.value
+ */
+
+exports.escapeNode = (block, n = 0, type) => {
+  const node = block.nodes[n];
+  if (!node) return;
+
+  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+    if (node.escaped !== true) {
+      node.value = '\\' + node.value;
+      node.escaped = true;
+    }
+  }
+};
+
+/**
+ * Returns true if the given brace node should be enclosed in literal braces
+ */
+
+exports.encloseBrace = node => {
+  if (node.type !== 'brace') return false;
+  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+    node.invalid = true;
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Returns true if a brace node is invalid.
+ */
+
+exports.isInvalidBrace = block => {
+  if (block.type !== 'brace') return false;
+  if (block.invalid === true || block.dollar) return true;
+  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+    block.invalid = true;
+    return true;
+  }
+  if (block.open !== true || block.close !== true) {
+    block.invalid = true;
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Returns true if a node is an open or close node
+ */
+
+exports.isOpenOrClose = node => {
+  if (node.type === 'open' || node.type === 'close') {
+    return true;
+  }
+  return node.open === true || node.close === true;
+};
+
+/**
+ * Reduce an array of text nodes.
+ */
+
+exports.reduce = nodes => nodes.reduce((acc, node) => {
+  if (node.type === 'text') acc.push(node.value);
+  if (node.type === 'range') node.type = 'text';
+  return acc;
+}, []);
+
+/**
+ * Flatten an array
+ */
+
+exports.flatten = (...args) => {
+  const result = [];
+
+  const flat = arr => {
+    for (let i = 0; i < arr.length; i++) {
+      const ele = arr[i];
+
+      if (Array.isArray(ele)) {
+        flat(ele);
+        continue;
+      }
+
+      if (ele !== undefined) {
+        result.push(ele);
+      }
+    }
+    return result;
+  };
+
+  flat(args);
+  return result;
+};

node_modules/@parcel/watcher/node_modules/braces/package.json

@@ -1,7 +1,7 @@
 {
   "name": "braces",
   "description": "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.",
-  "version": "2.3.2",
+  "version": "3.0.3",
   "homepage": "https://github.com/micromatch/braces",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "contributors": [
@@ -22,42 +22,20 @@
   ],
   "main": "index.js",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=8"
   },
   "scripts": {
     "test": "mocha",
     "benchmark": "node benchmark"
   },
   "dependencies": {
-    "arr-flatten": "^1.1.0",
-    "array-unique": "^0.3.2",
-    "extend-shallow": "^2.0.1",
-    "fill-range": "^4.0.0",
-    "isobject": "^3.0.1",
-    "repeat-element": "^1.1.2",
-    "snapdragon": "^0.8.1",
-    "snapdragon-node": "^2.0.1",
-    "split-string": "^3.0.2",
-    "to-regex": "^3.0.1"
+    "fill-range": "^7.1.1"
   },
   "devDependencies": {
-    "ansi-cyan": "^0.1.1",
-    "benchmarked": "^2.0.0",
-    "brace-expansion": "^1.1.8",
-    "cross-spawn": "^5.1.0",
-    "gulp": "^3.9.1",
-    "gulp-eslint": "^4.0.0",
-    "gulp-format-md": "^1.0.0",
-    "gulp-istanbul": "^1.1.2",
-    "gulp-mocha": "^3.0.1",
-    "gulp-unused": "^0.2.1",
-    "is-windows": "^1.0.1",
-    "minimatch": "^3.0.4",
-    "mocha": "^3.2.0",
-    "noncharacters": "^1.1.0",
-    "text-table": "^0.2.0",
-    "time-diff": "^0.3.1",
-    "yargs-parser": "^8.0.0"
+    "ansi-colors": "^3.2.4",
+    "bash-path": "^2.0.1",
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^6.1.1"
   },
   "keywords": [
     "alpha",
@@ -94,15 +72,6 @@
     },
     "plugins": [
       "gulp-format-md"
-    ],
-    "related": {
-      "list": [
-        "expand-brackets",
-        "extglob",
-        "fill-range",
-        "micromatch",
-        "nanomatch"
     ]
   }
-  }
 }

node_modules/@parcel/watcher/node_modules/fill-range/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+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.

node_modules/@parcel/watcher/node_modules/fill-range/README.md

@@ -1,21 +1,8 @@
-# fill-range [![NPM version](https://img.shields.io/npm/v/fill-range.svg?style=flat)](https://www.npmjs.com/package/fill-range) [![NPM monthly downloads](https://img.shields.io/npm/dm/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range)  [![NPM total downloads](https://img.shields.io/npm/dt/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/fill-range.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/fill-range)
+# fill-range [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [![NPM version](https://img.shields.io/npm/v/fill-range.svg?style=flat)](https://www.npmjs.com/package/fill-range) [![NPM monthly downloads](https://img.shields.io/npm/dm/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range) [![NPM total downloads](https://img.shields.io/npm/dt/fill-range.svg?style=flat)](https://npmjs.org/package/fill-range) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/fill-range.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/fill-range)
 
 > Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`
 
-## Table of Contents
-
-- [Install](#install)
-- [Usage](#usage)
-- [Examples](#examples)
-- [Options](#options)
-  * [options.step](#optionsstep)
-  * [options.strictRanges](#optionsstrictranges)
-  * [options.stringify](#optionsstringify)
-  * [options.toRegex](#optionstoregex)
-  * [options.transform](#optionstransform)
-- [About](#about)
-
-_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
 
 ## Install
 
@@ -25,23 +12,16 @@ Install with [npm](https://www.npmjs.com/):
 $ npm install --save fill-range
 ```
 
-Install with [yarn](https://yarnpkg.com):
-
-```sh
-$ yarn add fill-range
-```
-
 ## Usage
 
 Expands numbers and letters, optionally using a `step` as the last argument. _(Numbers may be defined as JavaScript numbers or strings)_.
 
 ```js
-var fill = require('fill-range');
-fill(from, to[, step, options]);
+const fill = require('fill-range');
+// fill(from, to[, step, options]);
 
-// examples
-console.log(fill('1', '10'));                  //=> '[ '1', '2', '3', '4', '5', '6', '7', '8', '9', '10' ]'
-console.log(fill('1', '10', {toRegex: true})); //=> [1-9]|10
+console.log(fill('1', '10')); //=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
+console.log(fill('1', '10', { toRegex: true })); //=> [1-9]|10
 ```
 
 **Params**
@@ -148,7 +128,7 @@ fill(1, 10, 'foo'); // invalid "step" argument
 
 ```js
 console.log(fill(1, 5));                    //=> [ 1, 2, 3, 4, 5 ]
-console.log(fill(1, 5, {stringify: true})); //=> [ '1', '2', '3', '4', '5' ]
+console.log(fill(1, 5, { stringify: true })); //=> [ '1', '2', '3', '4', '5' ]
 ```
 
 ### options.toRegex
@@ -163,13 +143,13 @@ console.log(fill(1, 5, {stringify: true})); //=> [ '1', '2', '3', '4', '5' ]
 
 ```js
 // alphabetical range
-console.log(fill('a', 'e', {toRegex: true})); //=> '[a-e]'
+console.log(fill('a', 'e', { toRegex: true })); //=> '[a-e]'
 // alphabetical with step
-console.log(fill('a', 'z', 3, {toRegex: true})); //=> 'a|d|g|j|m|p|s|v|y'
+console.log(fill('a', 'z', 3, { toRegex: true })); //=> 'a|d|g|j|m|p|s|v|y'
 // numerical range
-console.log(fill('1', '100', {toRegex: true})); //=> '[1-9]|[1-9][0-9]|100'
+console.log(fill('1', '100', { toRegex: true })); //=> '[1-9]|[1-9][0-9]|100'
 // numerical range with zero padding
-console.log(fill('000001', '100000', {toRegex: true}));
+console.log(fill('000001', '100000', { toRegex: true }));
 //=> '0{5}[1-9]|0{4}[1-9][0-9]|0{3}[1-9][0-9]{2}|0{2}[1-9][0-9]{3}|0[1-9][0-9]{4}|100000'
 ```
 
@@ -184,38 +164,33 @@ console.log(fill('000001', '100000', {toRegex: true}));
 **Example(s)**
 
 ```js
-// increase padding by two
-var arr = fill('01', '05', function(val, a, b, step, idx, arr, options) {
-  return repeat('0', (options.maxLength + 2) - val.length) + val;
-});
-
-console.log(arr);
+// add zero padding
+console.log(fill(1, 5, value => String(value).padStart(4, '0')));
 //=> ['0001', '0002', '0003', '0004', '0005']
 ```
 
 ## About
 
-### Related projects
-
-* [braces](https://www.npmjs.com/package/braces): Fast, comprehensive, bash-like brace expansion implemented in JavaScript. Complete support for the Bash 4.3 braces… [more](https://github.com/jonschlinkert/braces) | [homepage](https://github.com/jonschlinkert/braces "Fast, comprehensive, bash-like brace expansion implemented in JavaScript. Complete support for the Bash 4.3 braces specification, without sacrificing speed.")
-* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See the benchmarks. Used by micromatch.")
-* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/jonschlinkert/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
-* [to-regex-range](https://www.npmjs.com/package/to-regex-range): Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than… [more](https://github.com/jonschlinkert/to-regex-range) | [homepage](https://github.com/jonschlinkert/to-regex-range "Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.87 million test assertions.")
-
-### Contributing
+<details>
+<summary><strong>Contributing</strong></summary>
 
 Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
 
-### Contributors
+</details>
 
-| **Commits** | **Contributor** |  
-| --- | --- |  
-| 103 | [jonschlinkert](https://github.com/jonschlinkert) |  
-| 2   | [paulmillr](https://github.com/paulmillr) |  
-| 1   | [edorivai](https://github.com/edorivai) |  
-| 1   | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |  
+<details>
+<summary><strong>Running Tests</strong></summary>
 
-### Building docs
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
 
 _(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
 
@@ -225,26 +200,38 @@ To generate the readme, run the following command:
 $ npm install -g verbose/verb#dev verb-generate-readme && verb
 ```
 
-### Running tests
+</details>
 
-Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+### Contributors
 
-```sh
-$ npm install && npm test
-```
+| **Commits** | **Contributor** |  
+| --- | --- |  
+| 116 | [jonschlinkert](https://github.com/jonschlinkert) |  
+| 4   | [paulmillr](https://github.com/paulmillr) |  
+| 2   | [realityking](https://github.com/realityking) |  
+| 2   | [bluelovers](https://github.com/bluelovers) |  
+| 1   | [edorivai](https://github.com/edorivai) |  
+| 1   | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |  
 
 ### Author
 
 **Jon Schlinkert**
 
-* [github/jonschlinkert](https://github.com/jonschlinkert)
-* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
+
+<a href="https://www.patreon.com/jonschlinkert">
+<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" height="50">
+</a>
 
 ### License
 
-Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
 Released under the [MIT License](LICENSE).
 
 ***
 
-_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.5.0, on April 23, 2017._
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._

node_modules/@parcel/watcher/node_modules/fill-range/index.js

@@ -0,0 +1,248 @@
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+const util = require('util');
+const toRegexRange = require('to-regex-range');
+
+const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+const transform = toNumber => {
+  return value => toNumber === true ? Number(value) : String(value);
+};
+
+const isValidValue = value => {
+  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
+
+const isNumber = num => Number.isInteger(+num);
+
+const zeros = input => {
+  let value = `${input}`;
+  let index = -1;
+  if (value[0] === '-') value = value.slice(1);
+  if (value === '0') return false;
+  while (value[++index] === '0');
+  return index > 0;
+};
+
+const stringify = (start, end, options) => {
+  if (typeof start === 'string' || typeof end === 'string') {
+    return true;
+  }
+  return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+  if (maxLength > 0) {
+    let dash = input[0] === '-' ? '-' : '';
+    if (dash) input = input.slice(1);
+    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+  }
+  if (toNumber === false) {
+    return String(input);
+  }
+  return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+  let negative = input[0] === '-' ? '-' : '';
+  if (negative) {
+    input = input.slice(1);
+    maxLength--;
+  }
+  while (input.length < maxLength) input = '0' + input;
+  return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options, maxLen) => {
+  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+  let prefix = options.capture ? '' : '?:';
+  let positives = '';
+  let negatives = '';
+  let result;
+
+  if (parts.positives.length) {
+    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
+  }
+
+  if (parts.negatives.length) {
+    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
+  }
+
+  if (positives && negatives) {
+    result = `${positives}|${negatives}`;
+  } else {
+    result = positives || negatives;
+  }
+
+  if (options.wrap) {
+    return `(${prefix}${result})`;
+  }
+
+  return result;
+};
+
+const toRange = (a, b, isNumbers, options) => {
+  if (isNumbers) {
+    return toRegexRange(a, b, { wrap: false, ...options });
+  }
+
+  let start = String.fromCharCode(a);
+  if (a === b) return start;
+
+  let stop = String.fromCharCode(b);
+  return `[${start}-${stop}]`;
+};
+
+const toRegex = (start, end, options) => {
+  if (Array.isArray(start)) {
+    let wrap = options.wrap === true;
+    let prefix = options.capture ? '' : '?:';
+    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+  }
+  return toRegexRange(start, end, options);
+};
+
+const rangeError = (...args) => {
+  return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+};
+
+const invalidRange = (start, end, options) => {
+  if (options.strictRanges === true) throw rangeError([start, end]);
+  return [];
+};
+
+const invalidStep = (step, options) => {
+  if (options.strictRanges === true) {
+    throw new TypeError(`Expected step "${step}" to be a number`);
+  }
+  return [];
+};
+
+const fillNumbers = (start, end, step = 1, options = {}) => {
+  let a = Number(start);
+  let b = Number(end);
+
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    if (options.strictRanges === true) throw rangeError([start, end]);
+    return [];
+  }
+
+  // fix negative zero
+  if (a === 0) a = 0;
+  if (b === 0) b = 0;
+
+  let descending = a > b;
+  let startString = String(start);
+  let endString = String(end);
+  let stepString = String(step);
+  step = Math.max(Math.abs(step), 1);
+
+  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+  let toNumber = padded === false && stringify(start, end, options) === false;
+  let format = options.transform || transform(toNumber);
+
+  if (options.toRegex && step === 1) {
+    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+  }
+
+  let parts = { negatives: [], positives: [] };
+  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    if (options.toRegex === true && step > 1) {
+      push(a);
+    } else {
+      range.push(pad(format(a, index), maxLen, toNumber));
+    }
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return step > 1
+      ? toSequence(parts, options, maxLen)
+      : toRegex(range, null, { wrap: false, ...options });
+  }
+
+  return range;
+};
+
+const fillLetters = (start, end, step = 1, options = {}) => {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+    return invalidRange(start, end, options);
+  }
+
+  let format = options.transform || (val => String.fromCharCode(val));
+  let a = `${start}`.charCodeAt(0);
+  let b = `${end}`.charCodeAt(0);
+
+  let descending = a > b;
+  let min = Math.min(a, b);
+  let max = Math.max(a, b);
+
+  if (options.toRegex && step === 1) {
+    return toRange(min, max, false, options);
+  }
+
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    range.push(format(a, index));
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return toRegex(range, null, { wrap: false, options });
+  }
+
+  return range;
+};
+
+const fill = (start, end, step, options = {}) => {
+  if (end == null && isValidValue(start)) {
+    return [start];
+  }
+
+  if (!isValidValue(start) || !isValidValue(end)) {
+    return invalidRange(start, end, options);
+  }
+
+  if (typeof step === 'function') {
+    return fill(start, end, 1, { transform: step });
+  }
+
+  if (isObject(step)) {
+    return fill(start, end, 0, step);
+  }
+
+  let opts = { ...options };
+  if (opts.capture === true) opts.wrap = true;
+  step = step || opts.step || 1;
+
+  if (!isNumber(step)) {
+    if (step != null && !isObject(step)) return invalidStep(step, opts);
+    return fill(start, end, 1, step);
+  }
+
+  if (isNumber(start) && isNumber(end)) {
+    return fillNumbers(start, end, step, opts);
+  }
+
+  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+};
+
+module.exports = fill;

node_modules/@parcel/watcher/node_modules/fill-range/package.json

@@ -1,14 +1,15 @@
 {
   "name": "fill-range",
   "description": "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`",
-  "version": "4.0.0",
+  "version": "7.1.1",
   "homepage": "https://github.com/jonschlinkert/fill-range",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "contributors": [
-    "<wtgtybhertgeghgtwtg@gmail.com> (https://github.com/wtgtybhertgeghgtwtg)",
-    "Edo Rivai <edo.rivai@gmail.com> (edo.rivai.nl)",
-    "Jon Schlinkert <jon.schlinkert@sellside.com> (http://twitter.com/jonschlinkert)",
-    "Paul Miller <paul+gh@paulmillr.com> (paulmillr.com)"
+    "Edo Rivai (edo.rivai.nl)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Paul Miller (paulmillr.com)",
+    "Rouven Weßling (www.rouvenwessling.de)",
+    "(https://github.com/wtgtybhertgeghgtwtg)"
   ],
   "repository": "jonschlinkert/fill-range",
   "bugs": {
@@ -20,23 +21,22 @@
   ],
   "main": "index.js",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=8"
   },
   "scripts": {
-    "test": "mocha"
+    "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
+    "mocha": "mocha --reporter dot",
+    "test": "npm run lint && npm run mocha",
+    "test:ci": "npm run test:cover",
+    "test:cover": "nyc npm run mocha"
   },
   "dependencies": {
-    "extend-shallow": "^2.0.1",
-    "is-number": "^3.0.0",
-    "repeat-string": "^1.6.1",
-    "to-regex-range": "^2.1.0"
+    "to-regex-range": "^5.0.1"
   },
   "devDependencies": {
-    "ansi-cyan": "^0.1.1",
-    "benchmarked": "^1.0.0",
-    "gulp-format-md": "^0.1.12",
-    "minimist": "^1.2.0",
-    "mocha": "^3.2.0"
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^6.1.1",
+    "nyc": "^15.1.0"
   },
   "keywords": [
     "alpha",
@@ -59,15 +59,7 @@
     "sh"
   ],
   "verb": {
-    "related": {
-      "list": [
-        "braces",
-        "expand-range",
-        "micromatch",
-        "to-regex-range"
-      ]
-    },
-    "toc": true,
+    "toc": false,
     "layout": "default",
     "tasks": [
       "readme"

node_modules/@parcel/watcher/node_modules/is-number/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+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.

node_modules/@parcel/watcher/node_modules/is-number/README.md

@@ -0,0 +1,187 @@
+# is-number [![NPM version](https://img.shields.io/npm/v/is-number.svg?style=flat)](https://www.npmjs.com/package/is-number) [![NPM monthly downloads](https://img.shields.io/npm/dm/is-number.svg?style=flat)](https://npmjs.org/package/is-number) [![NPM total downloads](https://img.shields.io/npm/dt/is-number.svg?style=flat)](https://npmjs.org/package/is-number) [![Linux Build Status](https://img.shields.io/travis/jonschlinkert/is-number.svg?style=flat&label=Travis)](https://travis-ci.org/jonschlinkert/is-number)
+
+> Returns true if the value is a finite number.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save is-number
+```
+
+## Why is this needed?
+
+In JavaScript, it's not always as straightforward as it should be to reliably check if a value is a number. It's common for devs to use `+`, `-`, or `Number()` to cast a string value to a number (for example, when values are returned from user input, regex matches, parsers, etc). But there are many non-intuitive edge cases that yield unexpected results:
+
+```js
+console.log(+[]); //=> 0
+console.log(+''); //=> 0
+console.log(+'   '); //=> 0
+console.log(typeof NaN); //=> 'number'
+```
+
+This library offers a performant way to smooth out edge cases like these.
+
+## Usage
+
+```js
+const isNumber = require('is-number');
+```
+
+See the [tests](./test.js) for more examples.
+
+### true
+
+```js
+isNumber(5e3);               // true
+isNumber(0xff);              // true
+isNumber(-1.1);              // true
+isNumber(0);                 // true
+isNumber(1);                 // true
+isNumber(1.1);               // true
+isNumber(10);                // true
+isNumber(10.10);             // true
+isNumber(100);               // true
+isNumber('-1.1');            // true
+isNumber('0');               // true
+isNumber('012');             // true
+isNumber('0xff');            // true
+isNumber('1');               // true
+isNumber('1.1');             // true
+isNumber('10');              // true
+isNumber('10.10');           // true
+isNumber('100');             // true
+isNumber('5e3');             // true
+isNumber(parseInt('012'));   // true
+isNumber(parseFloat('012')); // true
+```
+
+### False
+
+Everything else is false, as you would expect:
+
+```js
+isNumber(Infinity);          // false
+isNumber(NaN);               // false
+isNumber(null);              // false
+isNumber(undefined);         // false
+isNumber('');                // false
+isNumber('   ');             // false
+isNumber('foo');             // false
+isNumber([1]);               // false
+isNumber([]);                // false
+isNumber(function () {});    // false
+isNumber({});                // false
+```
+
+## Release history
+
+### 7.0.0
+
+* Refactor. Now uses `.isFinite` if it exists.
+* Performance is about the same as v6.0 when the value is a string or number. But it's now 3x-4x faster when the value is not a string or number.
+
+### 6.0.0
+
+* Optimizations, thanks to @benaadams.
+
+### 5.0.0
+
+**Breaking changes**
+
+* removed support for `instanceof Number` and `instanceof String`
+
+## Benchmarks
+
+As with all benchmarks, take these with a grain of salt. See the [benchmarks](./benchmark/index.js) for more detail.
+
+```
+# all
+v7.0 x 413,222 ops/sec ±2.02% (86 runs sampled)
+v6.0 x 111,061 ops/sec ±1.29% (85 runs sampled)
+parseFloat x 317,596 ops/sec ±1.36% (86 runs sampled)
+fastest is 'v7.0'
+
+# string
+v7.0 x 3,054,496 ops/sec ±1.05% (89 runs sampled)
+v6.0 x 2,957,781 ops/sec ±0.98% (88 runs sampled)
+parseFloat x 3,071,060 ops/sec ±1.13% (88 runs sampled)
+fastest is 'parseFloat,v7.0'
+
+# number
+v7.0 x 3,146,895 ops/sec ±0.89% (89 runs sampled)
+v6.0 x 3,214,038 ops/sec ±1.07% (89 runs sampled)
+parseFloat x 3,077,588 ops/sec ±1.07% (87 runs sampled)
+fastest is 'v6.0'
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [is-plain-object](https://www.npmjs.com/package/is-plain-object): Returns true if an object was created by the `Object` constructor. | [homepage](https://github.com/jonschlinkert/is-plain-object "Returns true if an object was created by the `Object` constructor.")
+* [is-primitive](https://www.npmjs.com/package/is-primitive): Returns `true` if the value is a primitive.  | [homepage](https://github.com/jonschlinkert/is-primitive "Returns `true` if the value is a primitive. ")
+* [isobject](https://www.npmjs.com/package/isobject): Returns true if the value is an object and not an array or null. | [homepage](https://github.com/jonschlinkert/isobject "Returns true if the value is an object and not an array or null.")
+* [kind-of](https://www.npmjs.com/package/kind-of): Get the native type of a value. | [homepage](https://github.com/jonschlinkert/kind-of "Get the native type of a value.")
+
+### Contributors
+
+| **Commits** | **Contributor** | 
+| --- | --- |
+| 49 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 5 | [charlike-old](https://github.com/charlike-old) |
+| 1 | [benaadams](https://github.com/benaadams) |
+| 1 | [realityking](https://github.com/realityking) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on June 15, 2018._

node_modules/@parcel/watcher/node_modules/is-number/index.js

@@ -0,0 +1,18 @@
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+module.exports = function(num) {
+  if (typeof num === 'number') {
+    return num - num === 0;
+  }
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+  }
+  return false;
+};

node_modules/@parcel/watcher/node_modules/is-number/package.json

@@ -1,12 +1,13 @@
 {
   "name": "is-number",
-  "description": "Returns true if the value is a number. comprehensive tests.",
-  "version": "3.0.0",
+  "description": "Returns true if a number or string value is a finite number. Useful for regex matches, parsing, user input, etc.",
+  "version": "7.0.0",
   "homepage": "https://github.com/jonschlinkert/is-number",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "contributors": [
-    "Charlike Mike Reagent (http://www.tunnckocore.tk)",
-    "Jon Schlinkert <jon.schlinkert@sellside.com> (http://twitter.com/jonschlinkert)"
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Olsten Larck (https://i.am.charlike.online)",
+    "Rouven Weßling (www.rouvenwessling.de)"
   ],
   "repository": "jonschlinkert/is-number",
   "bugs": {
@@ -18,29 +19,31 @@
   ],
   "main": "index.js",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=0.12.0"
   },
   "scripts": {
     "test": "mocha"
   },
-  "dependencies": {
-    "kind-of": "^3.0.2"
-  },
   "devDependencies": {
-    "benchmarked": "^0.2.5",
-    "chalk": "^1.1.3",
-    "gulp-format-md": "^0.1.10",
-    "mocha": "^3.0.2"
+    "ansi": "^0.3.1",
+    "benchmark": "^2.1.4",
+    "gulp-format-md": "^1.0.0",
+    "mocha": "^3.5.3"
   },
   "keywords": [
+    "cast",
     "check",
     "coerce",
     "coercion",
+    "finite",
     "integer",
     "is",
+    "isnan",
     "is-nan",
     "is-num",
     "is-number",
+    "isnumber",
+    "isfinite",
     "istype",
     "kind",
     "math",
@@ -48,36 +51,32 @@
     "num",
     "number",
     "numeric",
+    "parseFloat",
+    "parseInt",
     "test",
     "type",
     "typeof",
     "value"
   ],
   "verb": {
-    "related": {
-      "list": [
-        "even",
-        "is-even",
-        "is-odd",
-        "is-primitive",
-        "kind-of",
-        "odd"
-      ]
-    },
     "toc": false,
     "layout": "default",
     "tasks": [
       "readme"
     ],
+    "related": {
+      "list": [
+        "is-plain-object",
+        "is-primitive",
+        "isobject",
+        "kind-of"
+      ]
+    },
     "plugins": [
       "gulp-format-md"
     ],
     "lint": {
       "reflinks": true
-    },
-    "reflinks": [
-      "verb",
-      "verb-generate-readme"
-    ]
+    }
   }
 }

node_modules/@parcel/watcher/node_modules/micromatch/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+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.

node_modules/@parcel/watcher/node_modules/micromatch/index.js

@@ -0,0 +1,474 @@
+'use strict';
+
+const util = require('util');
+const braces = require('braces');
+const picomatch = require('picomatch');
+const utils = require('picomatch/lib/utils');
+
+const isEmptyString = v => v === '' || v === './';
+const hasBraces = v => {
+  const index = v.indexOf('{');
+  return index > -1 && v.indexOf('}', index) > -1;
+};
+
+/**
+ * Returns an array of strings that match one or more glob patterns.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm(list, patterns[, options]);
+ *
+ * console.log(mm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {String|Array<string>} `list` List of strings to match.
+ * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options)
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+const micromatch = (list, patterns, options) => {
+  patterns = [].concat(patterns);
+  list = [].concat(list);
+
+  let omit = new Set();
+  let keep = new Set();
+  let items = new Set();
+  let negatives = 0;
+
+  let onResult = state => {
+    items.add(state.output);
+    if (options && options.onResult) {
+      options.onResult(state);
+    }
+  };
+
+  for (let i = 0; i < patterns.length; i++) {
+    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+    if (negated) negatives++;
+
+    for (let item of list) {
+      let matched = isMatch(item, true);
+
+      let match = negated ? !matched.isMatch : matched.isMatch;
+      if (!match) continue;
+
+      if (negated) {
+        omit.add(matched.output);
+      } else {
+        omit.delete(matched.output);
+        keep.add(matched.output);
+      }
+    }
+  }
+
+  let result = negatives === patterns.length ? [...items] : [...keep];
+  let matches = result.filter(item => !omit.has(item));
+
+  if (options && matches.length === 0) {
+    if (options.failglob === true) {
+      throw new Error(`No matches found for "${patterns.join(', ')}"`);
+    }
+
+    if (options.nonull === true || options.nullglob === true) {
+      return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns;
+    }
+  }
+
+  return matches;
+};
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.match = micromatch;
+
+/**
+ * Returns a matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matcher(pattern[, options]);
+ *
+ * const isMatch = mm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options`
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.isMatch(string, patterns[, options]);
+ *
+ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(mm.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `[options]` See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.any = micromatch.isMatch;
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.not(list, patterns[, options]);
+ *
+ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+micromatch.not = (list, patterns, options = {}) => {
+  patterns = [].concat(patterns).map(String);
+  let result = new Set();
+  let items = [];
+
+  let onResult = state => {
+    if (options.onResult) options.onResult(state);
+    items.push(state.output);
+  };
+
+  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
+
+  for (let item of items) {
+    if (!matches.has(item)) {
+      result.add(item);
+    }
+  }
+  return [...result];
+};
+
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var mm = require('micromatch');
+ * // mm.contains(string, pattern[, options]);
+ *
+ * console.log(mm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(mm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any of the patterns matches any part of `str`.
+ * @api public
+ */
+
+micromatch.contains = (str, pattern, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  if (Array.isArray(pattern)) {
+    return pattern.some(p => micromatch.contains(str, p, options));
+  }
+
+  if (typeof pattern === 'string') {
+    if (isEmptyString(str) || isEmptyString(pattern)) {
+      return false;
+    }
+
+    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {
+      return true;
+    }
+  }
+
+  return micromatch.isMatch(str, pattern, { ...options, contains: true });
+};
+
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matchKeys(object, patterns[, options]);
+ *
+ * const obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(mm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
+
+micromatch.matchKeys = (obj, patterns, options) => {
+  if (!utils.isObject(obj)) {
+    throw new TypeError('Expected the first argument to be an object');
+  }
+  let keys = micromatch(Object.keys(obj), patterns, options);
+  let res = {};
+  for (let key of keys) res[key] = obj[key];
+  return res;
+};
+
+/**
+ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.some(list, patterns[, options]);
+ *
+ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`
+ * @api public
+ */
+
+micromatch.some = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (items.some(item => isMatch(item))) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Returns true if every string in the given `list` matches
+ * any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.every(list, patterns[, options]);
+ *
+ * console.log(mm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`
+ * @api public
+ */
+
+micromatch.every = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (!items.every(item => isMatch(item))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Returns true if **all** of the given `patterns` match
+ * the specified string.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.all(string, patterns[, options]);
+ *
+ * console.log(mm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.all = (str, patterns, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  return [].concat(patterns).every(p => picomatch(p, options)(str));
+};
+
+/**
+ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.capture(pattern, string[, options]);
+ *
+ * console.log(mm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(mm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `glob` Glob pattern to use for matching.
+ * @param {String} `input` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+ * @api public
+ */
+
+micromatch.capture = (glob, input, options) => {
+  let posix = utils.isWindows(options);
+  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+
+  if (match) {
+    return match.slice(1).map(v => v === void 0 ? '' : v);
+  }
+};
+
+/**
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.makeRe(pattern[, options]);
+ *
+ * console.log(mm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+
+/**
+ * Scan a glob pattern to separate the pattern into segments. Used
+ * by the [split](#split) method.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.scan(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+micromatch.scan = (...args) => picomatch.scan(...args);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.parse(pattern[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as regex source string.
+ * @api public
+ */
+
+micromatch.parse = (patterns, options) => {
+  let res = [];
+  for (let pattern of [].concat(patterns || [])) {
+    for (let str of braces(String(pattern), options)) {
+      res.push(picomatch.parse(str, options));
+    }
+  }
+  return res;
+};
+
+/**
+ * Process the given brace `pattern`.
+ *
+ * ```js
+ * const { braces } = require('micromatch');
+ * console.log(braces('foo/{a,b,c}/bar'));
+ * //=> [ 'foo/(a|b|c)/bar' ]
+ *
+ * console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+ * ```
+ * @param {String} `pattern` String with brace pattern to process.
+ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
+ * @return {Array}
+ * @api public
+ */
+
+micromatch.braces = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
+    return [pattern];
+  }
+  return braces(pattern, options);
+};
+
+/**
+ * Expand braces
+ */
+
+micromatch.braceExpand = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  return micromatch.braces(pattern, { ...options, expand: true });
+};
+
+/**
+ * Expose micromatch
+ */
+
+// exposed for tests
+micromatch.hasBraces = hasBraces;
+module.exports = micromatch;

node_modules/@parcel/watcher/node_modules/micromatch/package.json

@@ -1,10 +1,11 @@
 {
   "name": "micromatch",
-  "description": "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.",
-  "version": "3.1.10",
+  "description": "Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.",
+  "version": "4.0.8",
   "homepage": "https://github.com/micromatch/micromatch",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "contributors": [
+    "(https://github.com/DianeLooney)",
     "Amila Welihinda (amilajack.com)",
     "Bogdan Chadkin (https://github.com/TrySound)",
     "Brian Woodward (https://twitter.com/doowb)",
@@ -17,7 +18,8 @@
     "Paul Miller (paulmillr.com)",
     "Tom Byrer (https://github.com/tomByrer)",
     "Tyler Akins (http://rumkin.com)",
-    "(https://github.com/DianeLooney)"
+    "Peter Bright <drpizza@quiscalusmexicanus.org> (https://github.com/drpizza)",
+    "Kuba Juszczyk (https://github.com/ku8ar)"
   ],
   "repository": "micromatch/micromatch",
   "bugs": {
@@ -25,50 +27,35 @@
   },
   "license": "MIT",
   "files": [
-    "index.js",
-    "lib"
+    "index.js"
   ],
   "main": "index.js",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=8.6"
   },
   "scripts": {
     "test": "mocha"
   },
   "dependencies": {
-    "arr-diff": "^4.0.0",
-    "array-unique": "^0.3.2",
-    "braces": "^2.3.1",
-    "define-property": "^2.0.2",
-    "extend-shallow": "^3.0.2",
-    "extglob": "^2.0.4",
-    "fragment-cache": "^0.2.1",
-    "kind-of": "^6.0.2",
-    "nanomatch": "^1.2.9",
-    "object.pick": "^1.3.0",
-    "regex-not": "^1.0.0",
-    "snapdragon": "^0.8.1",
-    "to-regex": "^3.0.2"
+    "braces": "^3.0.3",
+    "picomatch": "^2.3.1"
   },
   "devDependencies": {
-    "bash-match": "^1.0.2",
-    "for-own": "^1.0.0",
-    "gulp": "^3.9.1",
-    "gulp-format-md": "^1.0.0",
-    "gulp-istanbul": "^1.1.3",
-    "gulp-mocha": "^5.0.0",
-    "gulp-unused": "^0.2.1",
-    "is-windows": "^1.0.2",
-    "minimatch": "^3.0.4",
-    "minimist": "^1.2.0",
-    "mocha": "^3.5.3",
-    "multimatch": "^2.1.0"
+    "fill-range": "^7.0.1",
+    "gulp-format-md": "^2.0.0",
+    "minimatch": "^5.0.1",
+    "mocha": "^9.2.2",
+    "time-require": "github:jonschlinkert/time-require"
   },
   "keywords": [
     "bash",
+    "bracket",
+    "character-class",
     "expand",
     "expansion",
     "expression",
+    "extglob",
+    "extglobs",
     "file",
     "files",
     "filter",
@@ -77,6 +64,9 @@
     "globbing",
     "globs",
     "globstar",
+    "lookahead",
+    "lookaround",
+    "lookbehind",
     "match",
     "matcher",
     "matches",
@@ -84,33 +74,19 @@
     "micromatch",
     "minimatch",
     "multimatch",
+    "negate",
+    "negation",
     "path",
     "pattern",
     "patterns",
+    "posix",
     "regex",
     "regexp",
     "regular",
     "shell",
+    "star",
     "wildcard"
   ],
-  "lintDeps": {
-    "dependencies": {
-      "options": {
-        "lock": {
-          "snapdragon": "^0.8.1"
-        }
-      }
-    },
-    "devDependencies": {
-      "files": {
-        "options": {
-          "ignore": [
-            "benchmark/**"
-          ]
-        }
-      }
-    }
-  },
   "verb": {
     "toc": "collapsible",
     "layout": "default",
@@ -120,9 +96,9 @@
     "plugins": [
       "gulp-format-md"
     ],
-    "helpers": [
-      "./benchmark/helper.js"
-    ],
+    "lint": {
+      "reflinks": true
+    },
     "related": {
       "list": [
         "braces",
@@ -132,16 +108,12 @@
         "nanomatch"
       ]
     },
-    "lint": {
-      "reflinks": true
-    },
     "reflinks": [
-      "expand-brackets",
       "extglob",
+      "fill-range",
       "glob-object",
       "minimatch",
-      "multimatch",
-      "snapdragon"
+      "multimatch"
     ]
   }
 }

node_modules/@parcel/watcher/node_modules/to-regex-range/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+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.

node_modules/@parcel/watcher/node_modules/to-regex-range/README.md

@@ -0,0 +1,305 @@
+# to-regex-range [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [![NPM version](https://img.shields.io/npm/v/to-regex-range.svg?style=flat)](https://www.npmjs.com/package/to-regex-range) [![NPM monthly downloads](https://img.shields.io/npm/dm/to-regex-range.svg?style=flat)](https://npmjs.org/package/to-regex-range) [![NPM total downloads](https://img.shields.io/npm/dt/to-regex-range.svg?style=flat)](https://npmjs.org/package/to-regex-range) [![Linux Build Status](https://img.shields.io/travis/micromatch/to-regex-range.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/to-regex-range)
+
+> Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save to-regex-range
+```
+
+<details>
+<summary><strong>What does this do?</strong></summary>
+
+<br>
+
+This libary generates the `source` string to be passed to `new RegExp()` for matching a range of numbers.
+
+**Example**
+
+```js
+const toRegexRange = require('to-regex-range');
+const regex = new RegExp(toRegexRange('15', '95'));
+```
+
+A string is returned so that you can do whatever you need with it before passing it to `new RegExp()` (like adding `^` or `$` boundaries, defining flags, or combining it another string).
+
+<br>
+
+</details>
+
+<details>
+<summary><strong>Why use this library?</strong></summary>
+
+<br>
+
+### Convenience
+
+Creating regular expressions for matching numbers gets deceptively complicated pretty fast.
+
+For example, let's say you need a validation regex for matching part of a user-id, postal code, social security number, tax id, etc:
+
+* regex for matching `1` => `/1/` (easy enough)
+* regex for matching `1` through `5` => `/[1-5]/` (not bad...)
+* regex for matching `1` or `5` => `/(1|5)/` (still easy...)
+* regex for matching `1` through `50` => `/([1-9]|[1-4][0-9]|50)/` (uh-oh...)
+* regex for matching `1` through `55` => `/([1-9]|[1-4][0-9]|5[0-5])/` (no prob, I can do this...)
+* regex for matching `1` through `555` => `/([1-9]|[1-9][0-9]|[1-4][0-9]{2}|5[0-4][0-9]|55[0-5])/` (maybe not...)
+* regex for matching `0001` through `5555` => `/(0{3}[1-9]|0{2}[1-9][0-9]|0[1-9][0-9]{2}|[1-4][0-9]{3}|5[0-4][0-9]{2}|55[0-4][0-9]|555[0-5])/` (okay, I get the point!)
+
+The numbers are contrived, but they're also really basic. In the real world you might need to generate a regex on-the-fly for validation.
+
+**Learn more**
+
+If you're interested in learning more about [character classes](http://www.regular-expressions.info/charclass.html) and other regex features, I personally have always found [regular-expressions.info](http://www.regular-expressions.info/charclass.html) to be pretty useful.
+
+### Heavily tested
+
+As of April 07, 2019, this library runs [>1m test assertions](./test/test.js) against generated regex-ranges to provide brute-force verification that results are correct.
+
+Tests run in ~280ms on my MacBook Pro, 2.5 GHz Intel Core i7.
+
+### Optimized
+
+Generated regular expressions are optimized:
+
+* duplicate sequences and character classes are reduced using quantifiers
+* smart enough to use `?` conditionals when number(s) or range(s) can be positive or negative
+* uses fragment caching to avoid processing the same exact string more than once
+
+<br>
+
+</details>
+
+## Usage
+
+Add this library to your javascript application with the following line of code
+
+```js
+const toRegexRange = require('to-regex-range');
+```
+
+The main export is a function that takes two integers: the `min` value and `max` value (formatted as strings or numbers).
+
+```js
+const source = toRegexRange('15', '95');
+//=> 1[5-9]|[2-8][0-9]|9[0-5]
+
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('14')); //=> false
+console.log(regex.test('50')); //=> true
+console.log(regex.test('94')); //=> true
+console.log(regex.test('96')); //=> false
+```
+
+## Options
+
+### options.capture
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Wrap the returned value in parentheses when there is more than one regex condition. Useful when you're dynamically generating ranges.
+
+```js
+console.log(toRegexRange('-10', '10'));
+//=> -[1-9]|-?10|[0-9]
+
+console.log(toRegexRange('-10', '10', { capture: true }));
+//=> (-[1-9]|-?10|[0-9])
+```
+
+### options.shorthand
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Use the regex shorthand for `[0-9]`:
+
+```js
+console.log(toRegexRange('0', '999999'));
+//=> [0-9]|[1-9][0-9]{1,5}
+
+console.log(toRegexRange('0', '999999', { shorthand: true }));
+//=> \d|[1-9]\d{1,5}
+```
+
+### options.relaxZeros
+
+**Type**: `boolean`
+
+**Default**: `true`
+
+This option relaxes matching for leading zeros when when ranges are zero-padded.
+
+```js
+const source = toRegexRange('-0010', '0010');
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> true
+console.log(regex.test('-010')); //=> true
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> true
+console.log(regex.test('010')); //=> true
+console.log(regex.test('0010')); //=> true
+```
+
+When `relaxZeros` is false, matching is strict:
+
+```js
+const source = toRegexRange('-0010', '0010', { relaxZeros: false });
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> false
+console.log(regex.test('-010')); //=> false
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> false
+console.log(regex.test('010')); //=> false
+console.log(regex.test('0010')); //=> true
+```
+
+## Examples
+
+| **Range**                   | **Result**                                                                      | **Compile time** |
+| ---                         | ---                                                                             | ---              |
+| `toRegexRange(-10, 10)`     | `-[1-9]\|-?10\|[0-9]`                                                           | _132μs_          |
+| `toRegexRange(-100, -10)`   | `-1[0-9]\|-[2-9][0-9]\|-100`                                                    | _50μs_           |
+| `toRegexRange(-100, 100)`   | `-[1-9]\|-?[1-9][0-9]\|-?100\|[0-9]`                                            | _42μs_           |
+| `toRegexRange(001, 100)`    | `0{0,2}[1-9]\|0?[1-9][0-9]\|100`                                                | _109μs_          |
+| `toRegexRange(001, 555)`    | `0{0,2}[1-9]\|0?[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]`                | _51μs_           |
+| `toRegexRange(0010, 1000)`  | `0{0,2}1[0-9]\|0{0,2}[2-9][0-9]\|0?[1-9][0-9]{2}\|1000`                         | _31μs_           |
+| `toRegexRange(1, 50)`       | `[1-9]\|[1-4][0-9]\|50`                                                         | _24μs_           |
+| `toRegexRange(1, 55)`       | `[1-9]\|[1-4][0-9]\|5[0-5]`                                                     | _23μs_           |
+| `toRegexRange(1, 555)`      | `[1-9]\|[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]`                        | _30μs_           |
+| `toRegexRange(1, 5555)`     | `[1-9]\|[1-9][0-9]{1,2}\|[1-4][0-9]{3}\|5[0-4][0-9]{2}\|55[0-4][0-9]\|555[0-5]` | _43μs_           |
+| `toRegexRange(111, 555)`    | `11[1-9]\|1[2-9][0-9]\|[2-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]`                     | _38μs_           |
+| `toRegexRange(29, 51)`      | `29\|[34][0-9]\|5[01]`                                                          | _24μs_           |
+| `toRegexRange(31, 877)`     | `3[1-9]\|[4-9][0-9]\|[1-7][0-9]{2}\|8[0-6][0-9]\|87[0-7]`                       | _32μs_           |
+| `toRegexRange(5, 5)`        | `5`                                                                             | _8μs_            |
+| `toRegexRange(5, 6)`        | `5\|6`                                                                          | _11μs_           |
+| `toRegexRange(1, 2)`        | `1\|2`                                                                          | _6μs_            |
+| `toRegexRange(1, 5)`        | `[1-5]`                                                                         | _15μs_           |
+| `toRegexRange(1, 10)`       | `[1-9]\|10`                                                                     | _22μs_           |
+| `toRegexRange(1, 100)`      | `[1-9]\|[1-9][0-9]\|100`                                                        | _25μs_           |
+| `toRegexRange(1, 1000)`     | `[1-9]\|[1-9][0-9]{1,2}\|1000`                                                  | _31μs_           |
+| `toRegexRange(1, 10000)`    | `[1-9]\|[1-9][0-9]{1,3}\|10000`                                                 | _34μs_           |
+| `toRegexRange(1, 100000)`   | `[1-9]\|[1-9][0-9]{1,4}\|100000`                                                | _36μs_           |
+| `toRegexRange(1, 1000000)`  | `[1-9]\|[1-9][0-9]{1,5}\|1000000`                                               | _42μs_           |
+| `toRegexRange(1, 10000000)` | `[1-9]\|[1-9][0-9]{1,6}\|10000000`                                              | _42μs_           |
+
+## Heads up!
+
+**Order of arguments**
+
+When the `min` is larger than the `max`, values will be flipped to create a valid range:
+
+```js
+toRegexRange('51', '29');
+```
+
+Is effectively flipped to:
+
+```js
+toRegexRange('29', '51');
+//=> 29|[3-4][0-9]|5[0-1]
+```
+
+**Steps / increments**
+
+This library does not support steps (increments). A pr to add support would be welcome.
+
+## History
+
+### v2.0.0 - 2017-04-21
+
+**New features**
+
+Adds support for zero-padding!
+
+### v1.0.0
+
+**Optimizations**
+
+Repeating ranges are now grouped using quantifiers. rocessing time is roughly the same, but the generated regex is much smaller, which should result in faster matching.
+
+## Attribution
+
+Inspired by the python library [range-regex](https://github.com/dimka665/range-regex).
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used by micromatch.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
+* [repeat-element](https://www.npmjs.com/package/repeat-element): Create an array by repeating the given value n times. | [homepage](https://github.com/jonschlinkert/repeat-element "Create an array by repeating the given value n times.")
+* [repeat-string](https://www.npmjs.com/package/repeat-string): Repeat the given string n times. Fastest implementation for repeating a string. | [homepage](https://github.com/jonschlinkert/repeat-string "Repeat the given string n times. Fastest implementation for repeating a string.")
+
+### Contributors
+
+| **Commits** | **Contributor** |  
+| --- | --- |  
+| 63 | [jonschlinkert](https://github.com/jonschlinkert) |  
+| 3  | [doowb](https://github.com/doowb) |  
+| 2  | [realityking](https://github.com/realityking) |  
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
+
+<a href="https://www.patreon.com/jonschlinkert">
+<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" height="50">
+</a>
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 07, 2019._

node_modules/@parcel/watcher/node_modules/to-regex-range/index.js

@@ -0,0 +1,288 @@
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+const isNumber = require('is-number');
+
+const toRegexRange = (min, max, options) => {
+  if (isNumber(min) === false) {
+    throw new TypeError('toRegexRange: expected the first argument to be a number');
+  }
+
+  if (max === void 0 || min === max) {
+    return String(min);
+  }
+
+  if (isNumber(max) === false) {
+    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+  }
+
+  let opts = { relaxZeros: true, ...options };
+  if (typeof opts.strictZeros === 'boolean') {
+    opts.relaxZeros = opts.strictZeros === false;
+  }
+
+  let relax = String(opts.relaxZeros);
+  let shorthand = String(opts.shorthand);
+  let capture = String(opts.capture);
+  let wrap = String(opts.wrap);
+  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+    return toRegexRange.cache[cacheKey].result;
+  }
+
+  let a = Math.min(min, max);
+  let b = Math.max(min, max);
+
+  if (Math.abs(a - b) === 1) {
+    let result = min + '|' + max;
+    if (opts.capture) {
+      return `(${result})`;
+    }
+    if (opts.wrap === false) {
+      return result;
+    }
+    return `(?:${result})`;
+  }
+
+  let isPadded = hasPadding(min) || hasPadding(max);
+  let state = { min, max, a, b };
+  let positives = [];
+  let negatives = [];
+
+  if (isPadded) {
+    state.isPadded = isPadded;
+    state.maxLen = String(state.max).length;
+  }
+
+  if (a < 0) {
+    let newMin = b < 0 ? Math.abs(b) : 1;
+    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+    a = state.a = 0;
+  }
+
+  if (b >= 0) {
+    positives = splitToPatterns(a, b, state, opts);
+  }
+
+  state.negatives = negatives;
+  state.positives = positives;
+  state.result = collatePatterns(negatives, positives, opts);
+
+  if (opts.capture === true) {
+    state.result = `(${state.result})`;
+  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+    state.result = `(?:${state.result})`;
+  }
+
+  toRegexRange.cache[cacheKey] = state;
+  return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+  let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+  let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+  let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+  return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+  let nines = 1;
+  let zeros = 1;
+
+  let stop = countNines(min, nines);
+  let stops = new Set([max]);
+
+  while (min <= stop && stop <= max) {
+    stops.add(stop);
+    nines += 1;
+    stop = countNines(min, nines);
+  }
+
+  stop = countZeros(max + 1, zeros) - 1;
+
+  while (min < stop && stop <= max) {
+    stops.add(stop);
+    zeros += 1;
+    stop = countZeros(max + 1, zeros) - 1;
+  }
+
+  stops = [...stops];
+  stops.sort(compare);
+  return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+  if (start === stop) {
+    return { pattern: start, count: [], digits: 0 };
+  }
+
+  let zipped = zip(start, stop);
+  let digits = zipped.length;
+  let pattern = '';
+  let count = 0;
+
+  for (let i = 0; i < digits; i++) {
+    let [startDigit, stopDigit] = zipped[i];
+
+    if (startDigit === stopDigit) {
+      pattern += startDigit;
+
+    } else if (startDigit !== '0' || stopDigit !== '9') {
+      pattern += toCharacterClass(startDigit, stopDigit, options);
+
+    } else {
+      count++;
+    }
+  }
+
+  if (count) {
+    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+  }
+
+  return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+  let ranges = splitToRanges(min, max);
+  let tokens = [];
+  let start = min;
+  let prev;
+
+  for (let i = 0; i < ranges.length; i++) {
+    let max = ranges[i];
+    let obj = rangeToPattern(String(start), String(max), options);
+    let zeros = '';
+
+    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+      if (prev.count.length > 1) {
+        prev.count.pop();
+      }
+
+      prev.count.push(obj.count[0]);
+      prev.string = prev.pattern + toQuantifier(prev.count);
+      start = max + 1;
+      continue;
+    }
+
+    if (tok.isPadded) {
+      zeros = padZeros(max, tok, options);
+    }
+
+    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+    tokens.push(obj);
+    start = max + 1;
+    prev = obj;
+  }
+
+  return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+  let result = [];
+
+  for (let ele of arr) {
+    let { string } = ele;
+
+    // only push if _both_ are negative...
+    if (!intersection && !contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+
+    // or _both_ are positive
+    if (intersection && contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+  }
+  return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+  let arr = [];
+  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+  return arr;
+}
+
+function compare(a, b) {
+  return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+  return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+  return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+  let [start = 0, stop = ''] = digits;
+  if (stop || start > 1) {
+    return `{${start + (stop ? ',' + stop : '')}}`;
+  }
+  return '';
+}
+
+function toCharacterClass(a, b, options) {
+  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+  return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+  if (!tok.isPadded) {
+    return value;
+  }
+
+  let diff = Math.abs(tok.maxLen - String(value).length);
+  let relax = options.relaxZeros !== false;
+
+  switch (diff) {
+    case 0:
+      return '';
+    case 1:
+      return relax ? '0?' : '0';
+    case 2:
+      return relax ? '0{0,2}' : '00';
+    default: {
+      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+    }
+  }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange.cache = {};
+toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+module.exports = toRegexRange;

node_modules/@parcel/watcher/node_modules/to-regex-range/package.json

@@ -1,9 +1,13 @@
 {
   "name": "to-regex-range",
   "description": "Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.",
-  "version": "2.1.1",
+  "version": "5.0.1",
   "homepage": "https://github.com/micromatch/to-regex-range",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Rouven Weßling (www.rouvenwessling.de)"
+  ],
   "repository": "micromatch/to-regex-range",
   "bugs": {
     "url": "https://github.com/micromatch/to-regex-range/issues"
@@ -14,56 +18,49 @@
   ],
   "main": "index.js",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=8.0"
   },
   "scripts": {
     "test": "mocha"
   },
   "dependencies": {
-    "is-number": "^3.0.0",
-    "repeat-string": "^1.6.1"
+    "is-number": "^7.0.0"
   },
   "devDependencies": {
-    "fill-range": "^3.1.1",
-    "gulp-format-md": "^0.1.12",
-    "mocha": "^3.2.0",
+    "fill-range": "^6.0.0",
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^6.0.2",
     "text-table": "^0.2.0",
     "time-diff": "^0.3.1"
   },
   "keywords": [
-    "alpha",
-    "alphabetical",
     "bash",
-    "brace",
     "date",
     "expand",
     "expansion",
+    "expression",
     "glob",
     "match",
+    "match date",
+    "match number",
+    "match numbers",
+    "match year",
     "matches",
     "matching",
     "number",
+    "numbers",
     "numerical",
     "range",
     "ranges",
     "regex",
-    "sequence",
-    "sh",
-    "to",
-    "year"
+    "regexp",
+    "regular",
+    "regular expression",
+    "sequence"
   ],
   "verb": {
-    "related": {
-      "list": [
-        "expand-range",
-        "fill-range",
-        "micromatch",
-        "repeat-element",
-        "repeat-string"
-      ]
-    },
-    "toc": false,
     "layout": "default",
+    "toc": false,
     "tasks": [
       "readme"
     ],
@@ -73,14 +70,19 @@
     "lint": {
       "reflinks": true
     },
-    "helpers": [
-      "./examples.js"
-    ],
-    "reflinks": [
-      "0-5",
-      "0-9",
-      "1-5",
-      "1-9"
+    "helpers": {
+      "examples": {
+        "displayName": "examples"
+      }
+    },
+    "related": {
+      "list": [
+        "expand-range",
+        "fill-range",
+        "micromatch",
+        "repeat-element",
+        "repeat-string"
       ]
     }
+  }
 }

node_modules/@parcel/watcher/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@parcel/watcher",
+  "version": "2.5.1",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/watcher.git"
+  },
+  "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "files": [
+    "index.js",
+    "index.js.flow",
+    "index.d.ts",
+    "wrapper.js",
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "src",
+    "scripts/build-from-source.js",
+    "binding.gyp"
+  ],
+  "scripts": {
+    "prebuild": "prebuildify --napi --strip --tag-libc",
+    "format": "prettier --write \"./**/*.{js,json,md}\"",
+    "build": "node-gyp rebuild",
+    "install": "node scripts/build-from-source.js",
+    "test": "mocha"
+  },
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,json,md}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "dependencies": {
+    "detect-libc": "^1.0.3",
+    "is-glob": "^4.0.3",
+    "micromatch": "^4.0.5",
+    "node-addon-api": "^7.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.19.8",
+    "fs-extra": "^10.0.0",
+    "husky": "^7.0.2",
+    "lint-staged": "^11.1.2",
+    "mocha": "^9.1.1",
+    "napi-wasm": "^1.1.0",
+    "prebuildify": "^6.0.1",
+    "prettier": "^2.3.2"
+  },
+  "binary": {
+    "napi_versions": [
+      3
+    ]
+  },
+  "optionalDependencies": {
+    "@parcel/watcher-darwin-x64": "2.5.1",
+    "@parcel/watcher-darwin-arm64": "2.5.1",
+    "@parcel/watcher-win32-x64": "2.5.1",
+    "@parcel/watcher-win32-arm64": "2.5.1",
+    "@parcel/watcher-win32-ia32": "2.5.1",
+    "@parcel/watcher-linux-x64-glibc": "2.5.1",
+    "@parcel/watcher-linux-x64-musl": "2.5.1",
+    "@parcel/watcher-linux-arm64-glibc": "2.5.1",
+    "@parcel/watcher-linux-arm64-musl": "2.5.1",
+    "@parcel/watcher-linux-arm-glibc": "2.5.1",
+    "@parcel/watcher-linux-arm-musl": "2.5.1",
+    "@parcel/watcher-android-arm64": "2.5.1",
+    "@parcel/watcher-freebsd-x64": "2.5.1"
+  }
+}

node_modules/@parcel/watcher/scripts/build-from-source.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+const {spawn} = require('child_process');
+
+if (process.env.npm_config_build_from_source === 'true') {
+  build();
+}
+
+function build() {
+  spawn('node-gyp', ['rebuild'], { stdio: 'inherit', shell: true }).on('exit', function (code) {
+    process.exit(code);
+  });
+}

node_modules/@parcel/watcher/src/Backend.cc

@@ -0,0 +1,182 @@
+#ifdef FS_EVENTS
+#include "macos/FSEventsBackend.hh"
+#endif
+#ifdef WATCHMAN
+#include "watchman/WatchmanBackend.hh"
+#endif
+#ifdef WINDOWS
+#include "windows/WindowsBackend.hh"
+#endif
+#ifdef INOTIFY
+#include "linux/InotifyBackend.hh"
+#endif
+#ifdef KQUEUE
+#include "kqueue/KqueueBackend.hh"
+#endif
+#ifdef __wasm32__
+#include "wasm/WasmBackend.hh"
+#endif
+#include "shared/BruteForceBackend.hh"
+
+#include "Backend.hh"
+#include <unordered_map>
+
+static std::unordered_map<std::string, std::shared_ptr<Backend>> sharedBackends;
+
+std::shared_ptr<Backend> getBackend(std::string backend) {
+  // Use FSEvents on macOS by default.
+  // Use watchman by default if available on other platforms.
+  // Fall back to brute force.
+  #ifdef FS_EVENTS
+    if (backend == "fs-events" || backend == "default") {
+      return std::make_shared<FSEventsBackend>();
+    }
+  #endif
+  #ifdef WATCHMAN
+    if ((backend == "watchman" || backend == "default") && WatchmanBackend::checkAvailable()) {
+      return std::make_shared<WatchmanBackend>();
+    }
+  #endif
+  #ifdef WINDOWS
+    if (backend == "windows" || backend == "default") {
+      return std::make_shared<WindowsBackend>();
+    }
+  #endif
+  #ifdef INOTIFY
+    if (backend == "inotify" || backend == "default") {
+      return std::make_shared<InotifyBackend>();
+    }
+  #endif
+  #ifdef KQUEUE
+    if (backend == "kqueue" || backend == "default") {
+      return std::make_shared<KqueueBackend>();
+    }
+  #endif
+  #ifdef __wasm32__
+    if (backend == "wasm" || backend == "default") {
+      return std::make_shared<WasmBackend>();
+    }
+  #endif
+  if (backend == "brute-force" || backend == "default") {
+    return std::make_shared<BruteForceBackend>();
+  }
+
+  return nullptr;
+}
+
+std::shared_ptr<Backend> Backend::getShared(std::string backend) {
+  auto found = sharedBackends.find(backend);
+  if (found != sharedBackends.end()) {
+    return found->second;
+  }
+
+  auto result = getBackend(backend);
+  if (!result) {
+    return getShared("default");
+  }
+
+  result->run();
+  sharedBackends.emplace(backend, result);
+  return result;
+}
+
+void removeShared(Backend *backend) {
+  for (auto it = sharedBackends.begin(); it != sharedBackends.end(); it++) {
+    if (it->second.get() == backend) {
+      sharedBackends.erase(it);
+      break;
+    }
+  }
+
+  // Free up memory.
+  if (sharedBackends.size() == 0) {
+    sharedBackends.rehash(0);
+  }
+}
+
+void Backend::run() {
+  #ifndef __wasm32__
+    mThread = std::thread([this] () {
+      try {
+        start();
+      } catch (std::exception &err) {
+        handleError(err);
+      }
+    });
+
+    if (mThread.joinable()) {
+      mStartedSignal.wait();
+    }
+  #else
+    try {
+      start();
+    } catch (std::exception &err) {
+      handleError(err);
+    }
+  #endif
+}
+
+void Backend::notifyStarted() {
+  mStartedSignal.notify();
+}
+
+void Backend::start() {
+  notifyStarted();
+}
+
+Backend::~Backend() {
+  #ifndef __wasm32__
+    // Wait for thread to stop
+    if (mThread.joinable()) {
+      // If the backend is being destroyed from the thread itself, detach, otherwise join.
+      if (mThread.get_id() == std::this_thread::get_id()) {
+        mThread.detach();
+      } else {
+        mThread.join();
+      }
+    }
+  #endif
+}
+
+void Backend::watch(WatcherRef watcher) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  auto res = mSubscriptions.find(watcher);
+  if (res == mSubscriptions.end()) {
+    try {
+      this->subscribe(watcher);
+      mSubscriptions.insert(watcher);
+    } catch (std::exception &err) {
+      unref();
+      throw;
+    }
+  }
+}
+
+void Backend::unwatch(WatcherRef watcher) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  size_t deleted = mSubscriptions.erase(watcher);
+  if (deleted > 0) {
+    this->unsubscribe(watcher);
+    unref();
+  }
+}
+
+void Backend::unref() {
+  if (mSubscriptions.size() == 0) {
+    removeShared(this);
+  }
+}
+
+void Backend::handleWatcherError(WatcherError &err) {
+  unwatch(err.mWatcher);
+  err.mWatcher->notifyError(err);
+}
+
+void Backend::handleError(std::exception &err) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  for (auto it = mSubscriptions.begin(); it != mSubscriptions.end(); it++) {
+    (*it)->notifyError(err);
+  }
+
+  removeShared(this);
+}

node_modules/@parcel/watcher/src/Backend.hh

@@ -0,0 +1,37 @@
+#ifndef BACKEND_H
+#define BACKEND_H
+
+#include "Event.hh"
+#include "Watcher.hh"
+#include "Signal.hh"
+#include <thread>
+
+class Backend {
+public:
+  virtual ~Backend();
+  void run();
+  void notifyStarted();
+
+  virtual void start();
+  virtual void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) = 0;
+  virtual void getEventsSince(WatcherRef watcher, std::string *snapshotPath) = 0;
+  virtual void subscribe(WatcherRef watcher) = 0;
+  virtual void unsubscribe(WatcherRef watcher) = 0;
+
+  static std::shared_ptr<Backend> getShared(std::string backend);
+
+  void watch(WatcherRef watcher);
+  void unwatch(WatcherRef watcher);
+  void unref();
+  void handleWatcherError(WatcherError &err);
+
+  std::mutex mMutex;
+  std::thread mThread;
+private:
+  std::unordered_set<WatcherRef> mSubscriptions;
+  Signal mStartedSignal;
+
+  void handleError(std::exception &err);
+};
+
+#endif

node_modules/@parcel/watcher/src/Debounce.cc

@@ -0,0 +1,113 @@
+#include "Debounce.hh"
+
+#ifdef __wasm32__
+extern "C" void on_timeout(void *ctx) {
+  Debounce *debounce = (Debounce *)ctx;
+  debounce->notify();
+}
+#endif
+
+std::shared_ptr<Debounce> Debounce::getShared() {
+  static std::weak_ptr<Debounce> sharedInstance;
+  std::shared_ptr<Debounce> shared = sharedInstance.lock();
+  if (!shared) {
+    shared = std::make_shared<Debounce>();
+    sharedInstance = shared;
+  }
+
+  return shared;
+}
+
+Debounce::Debounce() {
+  mRunning = true;
+  #ifndef __wasm32__
+    mThread = std::thread([this] () {
+      loop();
+    });
+  #endif
+}
+
+Debounce::~Debounce() {
+  mRunning = false;
+  #ifndef __wasm32__
+    mWaitSignal.notify();
+    mThread.join();
+  #endif
+}
+
+void Debounce::add(void *key, std::function<void()> cb) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  mCallbacks.emplace(key, cb);
+}
+
+void Debounce::remove(void *key) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  mCallbacks.erase(key);
+}
+
+void Debounce::trigger() {
+  std::unique_lock<std::mutex> lock(mMutex);
+  #ifdef __wasm32__
+    notifyIfReady();
+  #else
+    mWaitSignal.notify();
+  #endif
+}
+
+#ifndef __wasm32__
+void Debounce::loop() {
+  while (mRunning) {
+    mWaitSignal.wait();
+    if (!mRunning) {
+      break;
+    }
+
+    notifyIfReady();
+  }
+}
+#endif
+
+void Debounce::notifyIfReady() {
+  if (!mRunning) {
+    return;
+  }
+
+  // If we haven't seen an event in more than the maximum wait time, notify callbacks immediately
+  // to ensure that we don't wait forever. Otherwise, wait for the minimum wait time and batch
+  // subsequent fast changes. This also means the first file change in a batch is notified immediately,
+  // separately from the rest of the batch. This seems like an acceptable tradeoff if the common case
+  // is that only a single file was updated at a time.
+  auto time = std::chrono::steady_clock::now();
+  if ((time - mLastTime) > std::chrono::milliseconds(MAX_WAIT_TIME)) {
+    mLastTime = time;
+    notify();
+  } else {
+    wait();
+  }
+}
+
+void Debounce::wait() {
+  #ifdef __wasm32__
+    clear_timeout(mTimeout);
+    mTimeout = set_timeout(MIN_WAIT_TIME, this);
+  #else
+    auto status = mWaitSignal.waitFor(std::chrono::milliseconds(MIN_WAIT_TIME));
+    if (mRunning && (status == std::cv_status::timeout)) {
+      notify();
+    }
+  #endif
+}
+
+void Debounce::notify() {
+  std::unique_lock<std::mutex> lock(mMutex);
+
+  mLastTime = std::chrono::steady_clock::now();
+  for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
+    auto cb = it->second;
+    cb();
+  }
+
+  #ifndef __wasm32__
+    mWaitSignal.reset();
+  #endif
+}

node_modules/@parcel/watcher/src/Debounce.hh

@@ -0,0 +1,49 @@
+#ifndef DEBOUNCE_H
+#define DEBOUNCE_H
+
+#include <thread>
+#include <unordered_map>
+#include <functional>
+#include "Signal.hh"
+
+#define MIN_WAIT_TIME 50
+#define MAX_WAIT_TIME 500
+
+#ifdef __wasm32__
+extern "C" {
+  int set_timeout(int ms, void *ctx);
+  void clear_timeout(int timeout);
+  void on_timeout(void *ctx);
+};
+#endif
+
+class Debounce {
+public:
+  static std::shared_ptr<Debounce> getShared();
+
+  Debounce();
+  ~Debounce();
+
+  void add(void *key, std::function<void()> cb);
+  void remove(void *key);
+  void trigger();
+  void notify();
+
+private:
+  bool mRunning;
+  std::mutex mMutex;
+  #ifdef __wasm32__
+    int mTimeout;
+  #else
+    Signal mWaitSignal;
+    std::thread mThread;
+  #endif
+  std::unordered_map<void *, std::function<void()>> mCallbacks;
+  std::chrono::time_point<std::chrono::steady_clock> mLastTime;
+
+  void loop();
+  void notifyIfReady();
+  void wait();
+};
+
+#endif

node_modules/@parcel/watcher/src/DirTree.cc

@@ -0,0 +1,152 @@
+#include "DirTree.hh"
+#include <inttypes.h>
+
+static std::mutex mDirCacheMutex;
+static std::unordered_map<std::string, std::weak_ptr<DirTree>> dirTreeCache;
+
+struct DirTreeDeleter {
+  void operator()(DirTree *tree) {
+    std::lock_guard<std::mutex> lock(mDirCacheMutex);
+    dirTreeCache.erase(tree->root);
+    delete tree;
+
+    // Free up memory.
+    if (dirTreeCache.size() == 0) {
+      dirTreeCache.rehash(0);
+    }
+  }
+};
+
+std::shared_ptr<DirTree> DirTree::getCached(std::string root) {
+  std::lock_guard<std::mutex> lock(mDirCacheMutex);
+
+  auto found = dirTreeCache.find(root);
+  std::shared_ptr<DirTree> tree;
+
+  // Use cached tree, or create an empty one.
+  if (found != dirTreeCache.end()) {
+    tree = found->second.lock();
+  } else {
+    tree = std::shared_ptr<DirTree>(new DirTree(root), DirTreeDeleter());
+    dirTreeCache.emplace(root, tree);
+  }
+
+  return tree;
+}
+
+DirTree::DirTree(std::string root, FILE *f) : root(root), isComplete(true) {
+  size_t size;
+  if (fscanf(f, "%zu", &size)) {
+    for (size_t i = 0; i < size; i++) {
+      DirEntry entry(f);
+      entries.emplace(entry.path, entry);
+    }
+  }
+}
+
+// Internal find method that has no lock
+DirEntry *DirTree::_find(std::string path) {
+  auto found = entries.find(path);
+  if (found == entries.end()) {
+    return NULL;
+  }
+
+  return &found->second;
+}
+
+DirEntry *DirTree::add(std::string path, uint64_t mtime, bool isDir) {
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  DirEntry entry(path, mtime, isDir);
+  auto it = entries.emplace(entry.path, entry);
+  return &it.first->second;
+}
+
+DirEntry *DirTree::find(std::string path) {
+  std::lock_guard<std::mutex> lock(mMutex);
+  return _find(path);
+}
+
+DirEntry *DirTree::update(std::string path, uint64_t mtime) {
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  DirEntry *found = _find(path);
+  if (found) {
+    found->mtime = mtime;
+  }
+
+  return found;
+}
+
+void DirTree::remove(std::string path) {
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  DirEntry *found = _find(path);
+
+  // Remove all sub-entries if this is a directory
+  if (found && found->isDir) {
+    std::string pathStart = path + DIR_SEP;
+    for (auto it = entries.begin(); it != entries.end();) {
+      if (it->first.rfind(pathStart, 0) == 0) {
+        it = entries.erase(it);
+      } else {
+        it++;
+      }
+    }
+  }
+
+  entries.erase(path);
+}
+
+void DirTree::write(FILE *f) {
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  fprintf(f, "%zu\n", entries.size());
+  for (auto it = entries.begin(); it != entries.end(); it++) {
+    it->second.write(f);
+  }
+}
+
+void DirTree::getChanges(DirTree *snapshot, EventList &events) {
+  std::lock_guard<std::mutex> lock(mMutex);
+  std::lock_guard<std::mutex> snapshotLock(snapshot->mMutex);
+
+  for (auto it = entries.begin(); it != entries.end(); it++) {
+    auto found = snapshot->entries.find(it->first);
+    if (found == snapshot->entries.end()) {
+      events.create(it->second.path);
+    } else if (found->second.mtime != it->second.mtime && !found->second.isDir && !it->second.isDir) {
+      events.update(it->second.path);
+    }
+  }
+
+  for (auto it = snapshot->entries.begin(); it != snapshot->entries.end(); it++) {
+    size_t count = entries.count(it->first);
+    if (count == 0) {
+      events.remove(it->second.path);
+    }
+  }
+}
+
+DirEntry::DirEntry(std::string p, uint64_t t, bool d) {
+  path = p;
+  mtime = t;
+  isDir = d;
+  state = NULL;
+}
+
+DirEntry::DirEntry(FILE *f) {
+  size_t size;
+  if (fscanf(f, "%zu", &size)) {
+    path.resize(size);
+    if (fread(&path[0], sizeof(char), size, f)) {
+      int d = 0;
+      fscanf(f, "%" PRIu64 " %d\n", &mtime, &d);
+      isDir = d == 1;
+    }
+  }
+}
+
+void DirEntry::write(FILE *f) const {
+  fprintf(f, "%zu%s%" PRIu64 " %d\n", path.size(), path.c_str(), mtime, isDir);
+}

node_modules/@parcel/watcher/src/DirTree.hh

@@ -0,0 +1,50 @@
+#ifndef DIR_TREE_H
+#define DIR_TREE_H
+
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include "Event.hh"
+
+#ifdef _WIN32
+#define DIR_SEP "\\"
+#else
+#define DIR_SEP "/"
+#endif
+
+struct DirEntry {
+  std::string path;
+  uint64_t mtime;
+  bool isDir;
+  mutable void *state;
+
+  DirEntry(std::string p, uint64_t t, bool d);
+  DirEntry(FILE *f);
+  void write(FILE *f) const;
+  bool operator==(const DirEntry &other) const {
+    return path == other.path;
+  }
+};
+
+class DirTree {
+public:
+  static std::shared_ptr<DirTree> getCached(std::string root);
+  DirTree(std::string root) : root(root), isComplete(false) {}
+  DirTree(std::string root, FILE *f);
+  DirEntry *add(std::string path, uint64_t mtime, bool isDir);
+  DirEntry *find(std::string path);
+  DirEntry *update(std::string path, uint64_t mtime);
+  void remove(std::string path);
+  void write(FILE *f);
+  void getChanges(DirTree *snapshot, EventList &events);
+
+  std::mutex mMutex;
+  std::string root;
+  bool isComplete;
+  std::unordered_map<std::string, DirEntry> entries;
+
+private:
+  DirEntry *_find(std::string path);
+};
+
+#endif

node_modules/@parcel/watcher/src/Event.hh

@@ -0,0 +1,109 @@
+#ifndef EVENT_H
+#define EVENT_H
+
+#include <string>
+#include <node_api.h>
+#include "wasm/include.h"
+#include <napi.h>
+#include <mutex>
+#include <map>
+#include <optional>
+
+using namespace Napi;
+
+struct Event {
+  std::string path;
+  bool isCreated;
+  bool isDeleted;
+  Event(std::string path) : path(path), isCreated(false), isDeleted(false) {}
+
+  Value toJS(const Env& env) {
+    EscapableHandleScope scope(env);
+    Object res = Object::New(env);
+    std::string type = isCreated ? "create" : isDeleted ? "delete" : "update";
+    res.Set(String::New(env, "path"), String::New(env, path.c_str()));
+    res.Set(String::New(env, "type"), String::New(env, type.c_str()));
+    return scope.Escape(res);
+  }
+};
+
+class EventList {
+public:
+  void create(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    Event *event = internalUpdate(path);
+    if (event->isDeleted) {
+      // Assume update event when rapidly removed and created
+      // https://github.com/parcel-bundler/watcher/issues/72
+      event->isDeleted = false;
+    } else {
+      event->isCreated = true;
+    }
+  }
+
+  Event *update(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    return internalUpdate(path);
+  }
+
+  void remove(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    Event *event = internalUpdate(path);
+    event->isDeleted = true;
+  }
+
+  size_t size() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mEvents.size();
+  }
+
+  std::vector<Event> getEvents() {
+    std::lock_guard<std::mutex> l(mMutex);
+    std::vector<Event> eventsCloneVector;
+    for(auto it = mEvents.begin(); it != mEvents.end(); ++it) {
+      if (!(it->second.isCreated && it->second.isDeleted)) {
+        eventsCloneVector.push_back(it->second);
+      }
+    }
+    return eventsCloneVector;
+  }
+
+  void clear() {
+    std::lock_guard<std::mutex> l(mMutex);
+    mEvents.clear();
+    mError.reset();
+  }
+
+  void error(std::string err) {
+    std::lock_guard<std::mutex> l(mMutex);
+    if (!mError.has_value()) {
+      mError.emplace(err);
+    }
+  }
+
+  bool hasError() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mError.has_value();
+  }
+
+  std::string getError() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mError.value_or("");
+  }
+
+private:
+  mutable std::mutex mMutex;
+  std::map<std::string, Event> mEvents;
+  std::optional<std::string> mError;
+  Event *internalUpdate(std::string path) {
+    auto found = mEvents.find(path);
+    if (found == mEvents.end()) {
+      auto it = mEvents.emplace(path, Event(path));
+      return &it.first->second;
+    }
+
+    return &found->second;
+  }
+};
+
+#endif

node_modules/@parcel/watcher/src/Glob.cc

@@ -0,0 +1,22 @@
+#include "Glob.hh"
+
+#ifdef __wasm32__
+extern "C" bool wasm_regex_match(const char *s, const char *regex);
+#endif
+
+Glob::Glob(std::string raw) {
+  mRaw = raw;
+  mHash = std::hash<std::string>()(raw);
+  #ifndef __wasm32__
+    mRegex = std::regex(raw);
+  #endif
+}
+
+bool Glob::isIgnored(std::string relative_path) const {
+  // Use native JS regex engine for wasm to reduce binary size.
+  #ifdef __wasm32__
+    return wasm_regex_match(relative_path.c_str(), mRaw.c_str());
+  #else
+    return std::regex_match(relative_path, mRegex);
+  #endif
+}

node_modules/@parcel/watcher/src/Glob.hh

@@ -0,0 +1,34 @@
+#ifndef GLOB_H
+#define GLOB_H
+
+#include <unordered_set>
+#include <regex>
+
+struct Glob {
+  std::size_t mHash;
+  std::string mRaw;
+  #ifndef __wasm32__
+  std::regex mRegex;
+  #endif
+
+  Glob(std::string raw);
+
+  bool operator==(const Glob &other) const {
+    return mHash == other.mHash;
+  }
+
+  bool isIgnored(std::string relative_path) const;
+};
+
+namespace std
+{
+  template <>
+  struct hash<Glob>
+  {
+    size_t operator()(const Glob& g) const {
+      return g.mHash;
+    }
+  };
+}
+
+#endif

node_modules/@parcel/watcher/src/PromiseRunner.hh

@@ -0,0 +1,101 @@
+#ifndef PROMISE_RUNNER_H
+#define PROMISE_RUNNER_H
+
+#include <node_api.h>
+#include "wasm/include.h"
+#include <napi.h>
+
+using namespace Napi;
+
+class PromiseRunner {
+public:
+  const Env env;
+  Promise::Deferred deferred;
+
+  PromiseRunner(Env env) : env(env), deferred(Promise::Deferred::New(env)) {
+    napi_status status = napi_create_async_work(env, nullptr, env.Undefined(),
+                                                onExecute, onWorkComplete, this, &work);
+    if (status != napi_ok) {
+      work = nullptr;
+      const napi_extended_error_info *error_info = 0;
+      napi_get_last_error_info(env, &error_info);
+      if (error_info->error_message) {
+        Error::New(env, error_info->error_message).ThrowAsJavaScriptException();
+      } else {
+        Error::New(env).ThrowAsJavaScriptException();
+      }
+    }
+  }
+
+  virtual ~PromiseRunner() {}
+
+  Value queue() {
+    if (work) {
+      napi_status status = napi_queue_async_work(env, work);
+      if (status != napi_ok) {
+        onError(Error::New(env));
+      }
+    }
+
+    return deferred.Promise();
+  }
+
+private:
+  napi_async_work work;
+  std::string error;
+
+  static void onExecute(napi_env env, void *this_pointer) {
+    PromiseRunner* self = (PromiseRunner*) this_pointer;
+    try {
+      self->execute();
+    } catch (std::exception &err) {
+      self->error = err.what();
+    }
+  }
+
+  static void onWorkComplete(napi_env env, napi_status status, void *this_pointer) {
+    PromiseRunner* self = (PromiseRunner*) this_pointer;
+    if (status != napi_cancelled) {
+      HandleScope scope(self->env);
+      if (status == napi_ok) {
+        status = napi_delete_async_work(self->env, self->work);
+        if (status == napi_ok) {
+          if (self->error.size() == 0) {
+            self->onOK();
+          } else {
+            self->onError(Error::New(self->env, self->error));
+          }
+          delete self;
+          return;
+        }
+      }
+    }
+
+    // fallthrough for error handling
+    const napi_extended_error_info *error_info = 0;
+    napi_get_last_error_info(env, &error_info);
+    if (error_info->error_message){
+      self->onError(Error::New(env, error_info->error_message));
+    } else {
+      self->onError(Error::New(env));
+    }
+    delete self;
+  }
+
+  virtual void execute() {}
+  virtual Value getResult() {
+    return env.Null();
+  }
+
+  void onOK() {
+    HandleScope scope(env);
+    Value result = getResult();
+    deferred.Resolve(result);
+  }
+
+  void onError(const Error &e) {
+    deferred.Reject(e.Value());
+  }
+};
+
+#endif

node_modules/@parcel/watcher/src/Signal.hh

@@ -0,0 +1,46 @@
+#ifndef SIGNAL_H
+#define SIGNAL_H
+
+#include <mutex>
+#include <condition_variable>
+
+class Signal {
+public:
+  Signal() : mFlag(false), mWaiting(false) {}
+  void wait() {
+    std::unique_lock<std::mutex> lock(mMutex);
+    while (!mFlag) {
+      mWaiting = true;
+      mCond.wait(lock);
+    }
+  }
+
+  std::cv_status waitFor(std::chrono::milliseconds ms) {
+    std::unique_lock<std::mutex> lock(mMutex);
+    return mCond.wait_for(lock, ms);
+  }
+
+  void notify() {
+    std::unique_lock<std::mutex> lock(mMutex);
+    mFlag = true;
+    mCond.notify_all();
+  }
+
+  void reset() {
+    std::unique_lock<std::mutex> lock(mMutex);
+    mFlag = false;
+    mWaiting = false;
+  }
+  
+  bool isWaiting() {
+    return mWaiting;
+  }
+
+private:
+  bool mFlag;
+  bool mWaiting;
+  std::mutex mMutex;
+  std::condition_variable mCond;
+};
+
+#endif

node_modules/@parcel/watcher/src/Watcher.cc

@@ -0,0 +1,237 @@
+#include "Watcher.hh"
+#include <unordered_set>
+
+using namespace Napi;
+
+struct WatcherHash {
+  std::size_t operator() (WatcherRef const &k) const {
+    return std::hash<std::string>()(k->mDir);
+  }
+};
+
+struct WatcherCompare {
+  size_t operator() (WatcherRef const &a, WatcherRef const &b) const {
+    return *a == *b;
+  }
+};
+
+static std::unordered_set<WatcherRef , WatcherHash, WatcherCompare> sharedWatchers;
+
+WatcherRef Watcher::getShared(std::string dir, std::unordered_set<std::string> ignorePaths, std::unordered_set<Glob> ignoreGlobs) {
+  WatcherRef watcher = std::make_shared<Watcher>(dir, ignorePaths, ignoreGlobs);
+  auto found = sharedWatchers.find(watcher);
+  if (found != sharedWatchers.end()) {
+    return *found;
+  }
+
+  sharedWatchers.insert(watcher);
+  return watcher;
+}
+
+void removeShared(Watcher *watcher) {
+  for (auto it = sharedWatchers.begin(); it != sharedWatchers.end(); it++) {
+    if (it->get() == watcher) {
+      sharedWatchers.erase(it);
+      break;
+    }
+  }
+
+  // Free up memory.
+  if (sharedWatchers.size() == 0) {
+    sharedWatchers.rehash(0);
+  }
+}
+
+Watcher::Watcher(std::string dir, std::unordered_set<std::string> ignorePaths, std::unordered_set<Glob> ignoreGlobs)
+  : mDir(dir),
+    mIgnorePaths(ignorePaths),
+    mIgnoreGlobs(ignoreGlobs) {
+      mDebounce = Debounce::getShared();
+      mDebounce->add(this, [this] () {
+        triggerCallbacks();
+      });
+    }
+
+Watcher::~Watcher() {
+  mDebounce->remove(this);
+}
+
+void Watcher::wait() {
+  std::unique_lock<std::mutex> lk(mMutex);
+  mCond.wait(lk);
+}
+
+void Watcher::notify() {
+  std::unique_lock<std::mutex> lk(mMutex);
+  mCond.notify_all();
+
+  if (mCallbacks.size() > 0 && mEvents.size() > 0) {
+    // We must release our lock before calling into the debouncer
+    // to avoid a deadlock: the debouncer thread itself will require
+    // our lock from its thread when calling into `triggerCallbacks`
+    // while holding its own debouncer lock.
+    lk.unlock();
+    mDebounce->trigger();
+  }
+}
+
+struct CallbackData {
+  std::string error;
+  std::vector<Event> events;
+  CallbackData(std::string error, std::vector<Event> events) : error(error), events(events) {}
+};
+
+Value callbackEventsToJS(const Env &env, std::vector<Event> &events) {
+  EscapableHandleScope scope(env);
+  Array arr = Array::New(env, events.size());
+  size_t currentEventIndex = 0;
+  for (auto eventIterator = events.begin(); eventIterator != events.end(); eventIterator++) {
+    arr.Set(currentEventIndex++, eventIterator->toJS(env));
+  }
+  return scope.Escape(arr);
+}
+
+void callJSFunction(Napi::Env env, Function jsCallback, CallbackData *data) {
+  HandleScope scope(env);
+  auto err = data->error.size() > 0 ? Error::New(env, data->error).Value() : env.Null();
+  auto events = callbackEventsToJS(env, data->events);
+  jsCallback.Call({err, events});
+  delete data;
+
+  // Throw errors from the callback as fatal exceptions
+  // If we don't handle these node segfaults...
+  if (env.IsExceptionPending()) {
+    Napi::Error err = env.GetAndClearPendingException();
+    napi_fatal_exception(env, err.Value());
+  }
+}
+
+void Watcher::notifyError(std::exception &err) {
+  std::unique_lock<std::mutex> lk(mMutex);
+  for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
+    CallbackData *data = new CallbackData(err.what(), {});
+    it->tsfn.BlockingCall(data, callJSFunction);
+  }
+
+  clearCallbacks();
+}
+
+// This function is called from the debounce thread.
+void Watcher::triggerCallbacks() {
+  std::unique_lock<std::mutex> lk(mMutex);
+  if (mCallbacks.size() > 0 && (mEvents.size() > 0 || mEvents.hasError())) {
+    auto error = mEvents.getError();
+    auto events = mEvents.getEvents();
+    mEvents.clear();
+
+    for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
+      it->tsfn.BlockingCall(new CallbackData(error, events), callJSFunction);
+    }
+  }
+}
+
+// This should be called from the JavaScript thread.
+bool Watcher::watch(Function callback) {
+  std::unique_lock<std::mutex> lk(mMutex);
+
+  auto it = findCallback(callback);
+  if (it != mCallbacks.end()) {
+    return false;
+  }
+
+  auto tsfn = ThreadSafeFunction::New(
+    callback.Env(),
+    callback,
+    "Watcher callback",
+    0, // Unlimited queue
+    1 // Initial thread count
+  );
+
+  mCallbacks.push_back(Callback {
+    tsfn,
+    Napi::Persistent(callback),
+    std::this_thread::get_id()
+  });
+
+  return true;
+}
+
+// This should be called from the JavaScript thread.
+std::vector<Callback>::iterator Watcher::findCallback(Function callback) {
+  for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
+    // Only consider callbacks created by the same thread, or V8 will panic.
+    if (it->threadId == std::this_thread::get_id() && it->ref.Value() == callback) {
+      return it;
+    }
+  }
+
+  return mCallbacks.end();
+}
+
+// This should be called from the JavaScript thread.
+bool Watcher::unwatch(Function callback) {
+  std::unique_lock<std::mutex> lk(mMutex);
+
+  bool removed = false;
+  auto it = findCallback(callback);
+  if (it != mCallbacks.end()) {
+    it->tsfn.Release();
+    it->ref.Unref();
+    mCallbacks.erase(it);
+    removed = true;
+  }
+
+  if (removed && mCallbacks.size() == 0) {
+    unref();
+    return true;
+  }
+
+  return false;
+}
+
+void Watcher::unref() {
+  if (mCallbacks.size() == 0) {
+    removeShared(this);
+  }
+}
+
+void Watcher::destroy() {
+  std::unique_lock<std::mutex> lk(mMutex);
+  clearCallbacks();
+}
+
+// Private because it doesn't lock.
+void Watcher::clearCallbacks() {
+  for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
+    it->tsfn.Release();
+    it->ref.Unref();
+  }
+
+  mCallbacks.clear();
+  unref();
+}
+
+bool Watcher::isIgnored(std::string path) {
+  for (auto it = mIgnorePaths.begin(); it != mIgnorePaths.end(); it++) {
+    auto dir = *it + DIR_SEP;
+    if (*it == path || path.compare(0, dir.size(), dir) == 0) {
+      return true;
+    }
+  }
+
+  auto basePath = mDir + DIR_SEP;
+
+  if (path.rfind(basePath, 0) != 0) {
+    return false;
+  }
+
+  auto relativePath = path.substr(basePath.size());
+
+  for (auto it = mIgnoreGlobs.begin(); it != mIgnoreGlobs.end(); it++) {
+    if (it->isIgnored(relativePath)) {
+      return true;
+    }
+  }
+
+  return false;
+}

node_modules/@parcel/watcher/src/Watcher.hh

@@ -0,0 +1,73 @@
+#ifndef WATCHER_H
+#define WATCHER_H
+
+#include <condition_variable>
+#include <unordered_set>
+#include <set>
+#include <node_api.h>
+#include "Glob.hh"
+#include "Event.hh"
+#include "Debounce.hh"
+#include "DirTree.hh"
+#include "Signal.hh"
+
+using namespace Napi;
+
+struct Watcher;
+using WatcherRef = std::shared_ptr<Watcher>;
+
+struct Callback {
+  Napi::ThreadSafeFunction tsfn;
+  Napi::FunctionReference ref;
+  std::thread::id threadId;
+};
+
+class WatcherState {
+public:
+    virtual ~WatcherState() = default;
+};
+
+struct Watcher {
+  std::string mDir;
+  std::unordered_set<std::string> mIgnorePaths;
+  std::unordered_set<Glob> mIgnoreGlobs;
+  EventList mEvents;
+  std::shared_ptr<WatcherState> state;
+
+  Watcher(std::string dir, std::unordered_set<std::string> ignorePaths, std::unordered_set<Glob> ignoreGlobs);
+  ~Watcher();
+
+  bool operator==(const Watcher &other) const {
+    return mDir == other.mDir && mIgnorePaths == other.mIgnorePaths && mIgnoreGlobs == other.mIgnoreGlobs;
+  }
+
+  void wait();
+  void notify();
+  void notifyError(std::exception &err);
+  bool watch(Function callback);
+  bool unwatch(Function callback);
+  void unref();
+  bool isIgnored(std::string path);
+  void destroy();
+
+  static WatcherRef getShared(std::string dir, std::unordered_set<std::string> ignorePaths, std::unordered_set<Glob> ignoreGlobs);
+
+private:
+  std::mutex mMutex;
+  std::condition_variable mCond;
+  std::vector<Callback> mCallbacks;
+  std::shared_ptr<Debounce> mDebounce;
+
+  std::vector<Callback>::iterator findCallback(Function callback);
+  void clearCallbacks();
+  void triggerCallbacks();
+};
+
+class WatcherError : public std::runtime_error {
+public:
+  WatcherRef mWatcher;
+  WatcherError(std::string msg, WatcherRef watcher) : std::runtime_error(msg), mWatcher(watcher) {}
+  WatcherError(const char *msg, WatcherRef watcher) : std::runtime_error(msg), mWatcher(watcher) {}
+};
+
+#endif

node_modules/@parcel/watcher/src/binding.cc

@@ -0,0 +1,268 @@
+#include <unordered_set>
+#include <node_api.h>
+#include "wasm/include.h"
+#include <napi.h>
+#include "Glob.hh"
+#include "Event.hh"
+#include "Backend.hh"
+#include "Watcher.hh"
+#include "PromiseRunner.hh"
+
+using namespace Napi;
+
+std::unordered_set<std::string> getIgnorePaths(Env env, Value opts) {
+  std::unordered_set<std::string> result;
+
+  if (opts.IsObject()) {
+    Value v = opts.As<Object>().Get(String::New(env, "ignorePaths"));
+    if (v.IsArray()) {
+      Array items = v.As<Array>();
+      for (size_t i = 0; i < items.Length(); i++) {
+        Value item = items.Get(Number::New(env, i));
+        if (item.IsString()) {
+          result.insert(std::string(item.As<String>().Utf8Value().c_str()));
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+std::unordered_set<Glob> getIgnoreGlobs(Env env, Value opts) {
+  std::unordered_set<Glob> result;
+
+  if (opts.IsObject()) {
+    Value v = opts.As<Object>().Get(String::New(env, "ignoreGlobs"));
+    if (v.IsArray()) {
+      Array items = v.As<Array>();
+      for (size_t i = 0; i < items.Length(); i++) {
+        Value item = items.Get(Number::New(env, i));
+        if (item.IsString()) {
+          auto key = item.As<String>().Utf8Value();
+          try {
+            result.emplace(key);
+          } catch (const std::regex_error& e) {
+            Error::New(env, e.what()).ThrowAsJavaScriptException();
+          }
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+std::shared_ptr<Backend> getBackend(Env env, Value opts) {
+  Value b = opts.As<Object>().Get(String::New(env, "backend"));
+  std::string backendName;
+  if (b.IsString()) {
+    backendName = std::string(b.As<String>().Utf8Value().c_str());
+  }
+
+  return Backend::getShared(backendName);
+}
+
+class WriteSnapshotRunner : public PromiseRunner {
+public:
+  WriteSnapshotRunner(Env env, Value dir, Value snap, Value opts)
+    : PromiseRunner(env),
+      snapshotPath(std::string(snap.As<String>().Utf8Value().c_str())) {
+    watcher = Watcher::getShared(
+      std::string(dir.As<String>().Utf8Value().c_str()),
+      getIgnorePaths(env, opts),
+      getIgnoreGlobs(env, opts)
+    );
+
+    backend = getBackend(env, opts);
+  }
+
+  ~WriteSnapshotRunner() {
+    watcher->unref();
+    backend->unref();
+  }
+private:
+  std::shared_ptr<Backend> backend;
+  WatcherRef watcher;
+  std::string snapshotPath;
+
+  void execute() override {
+    backend->writeSnapshot(watcher, &snapshotPath);
+  }
+};
+
+class GetEventsSinceRunner : public PromiseRunner {
+public:
+  GetEventsSinceRunner(Env env, Value dir, Value snap, Value opts)
+    : PromiseRunner(env),
+      snapshotPath(std::string(snap.As<String>().Utf8Value().c_str())) {
+    watcher = std::make_shared<Watcher>(
+      std::string(dir.As<String>().Utf8Value().c_str()),
+      getIgnorePaths(env, opts),
+      getIgnoreGlobs(env, opts)
+    );
+
+    backend = getBackend(env, opts);
+  }
+
+  ~GetEventsSinceRunner() {
+    watcher->unref();
+    backend->unref();
+  }
+private:
+  std::shared_ptr<Backend> backend;
+  WatcherRef watcher;
+  std::string snapshotPath;
+
+  void execute() override {
+    backend->getEventsSince(watcher, &snapshotPath);
+    if (watcher->mEvents.hasError()) {
+      throw std::runtime_error(watcher->mEvents.getError());
+    }
+  }
+
+  Value getResult() override {
+    std::vector<Event> events = watcher->mEvents.getEvents();
+    Array eventsArray = Array::New(env, events.size());
+    size_t i = 0;
+    for (auto it = events.begin(); it != events.end(); it++) {
+      eventsArray.Set(i++, it->toJS(env));
+    }
+    return eventsArray;
+  }
+};
+
+template<class Runner>
+Value queueSnapshotWork(const CallbackInfo& info) {
+  Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    TypeError::New(env, "Expected a string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() < 2 || !info[1].IsString()) {
+    TypeError::New(env, "Expected a string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() >= 3 && !info[2].IsObject()) {
+    TypeError::New(env, "Expected an object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Runner *runner = new Runner(info.Env(), info[0], info[1], info[2]);
+  return runner->queue();
+}
+
+Value writeSnapshot(const CallbackInfo& info) {
+  return queueSnapshotWork<WriteSnapshotRunner>(info);
+}
+
+Value getEventsSince(const CallbackInfo& info) {
+  return queueSnapshotWork<GetEventsSinceRunner>(info);
+}
+
+class SubscribeRunner : public PromiseRunner {
+public:
+  SubscribeRunner(Env env, Value dir, Value fn, Value opts) : PromiseRunner(env) {
+    watcher = Watcher::getShared(
+      std::string(dir.As<String>().Utf8Value().c_str()),
+      getIgnorePaths(env, opts),
+      getIgnoreGlobs(env, opts)
+    );
+
+    backend = getBackend(env, opts);
+    watcher->watch(fn.As<Function>());
+  }
+
+private:
+  WatcherRef watcher;
+  std::shared_ptr<Backend> backend;
+  FunctionReference callback;
+
+  void execute() override {
+    try {
+      backend->watch(watcher);
+    } catch (std::exception &err) {
+      watcher->destroy();
+      throw;
+    }
+  }
+};
+
+class UnsubscribeRunner : public PromiseRunner {
+public:
+  UnsubscribeRunner(Env env, Value dir, Value fn, Value opts) : PromiseRunner(env) {
+    watcher = Watcher::getShared(
+      std::string(dir.As<String>().Utf8Value().c_str()),
+      getIgnorePaths(env, opts),
+      getIgnoreGlobs(env, opts)
+    );
+
+    backend = getBackend(env, opts);
+    shouldUnwatch = watcher->unwatch(fn.As<Function>());
+  }
+
+private:
+  WatcherRef watcher;
+  std::shared_ptr<Backend> backend;
+  bool shouldUnwatch;
+
+  void execute() override {
+    if (shouldUnwatch) {
+      backend->unwatch(watcher);
+    }
+  }
+};
+
+template<class Runner>
+Value queueSubscriptionWork(const CallbackInfo& info) {
+  Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    TypeError::New(env, "Expected a string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() < 2 || !info[1].IsFunction()) {
+    TypeError::New(env, "Expected a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() >= 3 && !info[2].IsObject()) {
+    TypeError::New(env, "Expected an object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Runner *runner = new Runner(info.Env(), info[0], info[1], info[2]);
+  return runner->queue();
+}
+
+Value subscribe(const CallbackInfo& info) {
+  return queueSubscriptionWork<SubscribeRunner>(info);
+}
+
+Value unsubscribe(const CallbackInfo& info) {
+  return queueSubscriptionWork<UnsubscribeRunner>(info);
+}
+
+Object Init(Env env, Object exports) {
+  exports.Set(
+    String::New(env, "writeSnapshot"),
+    Function::New(env, writeSnapshot)
+  );
+  exports.Set(
+    String::New(env, "getEventsSince"),
+    Function::New(env, getEventsSince)
+  );
+  exports.Set(
+    String::New(env, "subscribe"),
+    Function::New(env, subscribe)
+  );
+  exports.Set(
+    String::New(env, "unsubscribe"),
+    Function::New(env, unsubscribe)
+  );
+  return exports;
+}
+
+NODE_API_MODULE(watcher, Init)

node_modules/@parcel/watcher/src/kqueue/KqueueBackend.cc

@@ -0,0 +1,306 @@
+#include <memory>
+#include <poll.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include "KqueueBackend.hh"
+
+#if __APPLE__
+#define st_mtim st_mtimespec
+#endif
+
+#if !defined(O_EVTONLY)
+#define O_EVTONLY O_RDONLY
+#endif
+
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+
+void KqueueBackend::start() {
+  if ((mKqueue = kqueue()) < 0) {
+    throw std::runtime_error(std::string("Unable to open kqueue: ") + strerror(errno));
+  }
+
+  // Create a pipe that we will write to when we want to end the thread.
+  int err = pipe(mPipe);
+  if (err == -1) {
+    throw std::runtime_error(std::string("Unable to open pipe: ") + strerror(errno));
+  }
+
+  // Subscribe kqueue to this pipe.
+  struct kevent ev;
+  EV_SET(
+    &ev,
+    mPipe[0],
+    EVFILT_READ,
+    EV_ADD | EV_CLEAR,
+    0,
+    0,
+    0
+  );
+
+  if (kevent(mKqueue, &ev, 1, NULL, 0, 0)) {
+    close(mPipe[0]);
+    close(mPipe[1]);
+    throw std::runtime_error(std::string("Unable to watch pipe: ") + strerror(errno));
+  }
+
+  notifyStarted();
+
+  struct kevent events[128];
+
+  while (true) {
+    int event_count = kevent(mKqueue, NULL, 0, events, 128, 0);
+    if (event_count < 0 || events[0].flags == EV_ERROR) {
+      throw std::runtime_error(std::string("kevent error: ") + strerror(errno));
+    }
+
+    // Track all of the watchers that are touched so we can notify them at the end of the events.
+    std::unordered_set<WatcherRef> watchers;
+
+    for (int i = 0; i < event_count; i++) {
+      int flags = events[i].fflags;
+      int fd = events[i].ident;
+      if (fd == mPipe[0]) {
+        // pipe was written to. break out of the loop.
+        goto done;
+      }
+
+      auto it = mFdToEntry.find(fd);
+      if (it == mFdToEntry.end()) {
+        // If fd wasn't in our map, we may have already stopped watching it. Ignore the event.
+        continue;
+      }
+
+      DirEntry *entry = it->second;
+
+      if (flags & NOTE_WRITE && entry && entry->isDir) {
+        // If a write occurred on a directory, we have to diff the contents of that
+        // directory to determine what file was added/deleted.
+        compareDir(fd, entry->path, watchers);
+      } else {
+        std::vector<KqueueSubscription *> subs = findSubscriptions(entry->path);
+        for (auto it = subs.begin(); it != subs.end(); it++) {
+          KqueueSubscription *sub = *it;
+          watchers.insert(sub->watcher);
+          if (flags & (NOTE_DELETE | NOTE_RENAME | NOTE_REVOKE)) {
+            sub->watcher->mEvents.remove(sub->path);
+            sub->tree->remove(sub->path);
+            mFdToEntry.erase((int)(size_t)entry->state);
+            mSubscriptions.erase(sub->path);
+          } else if (flags & (NOTE_WRITE | NOTE_ATTRIB | NOTE_EXTEND)) {
+            struct stat st;
+            lstat(sub->path.c_str(), &st);
+            if (entry->mtime != CONVERT_TIME(st.st_mtim)) {
+              entry->mtime = CONVERT_TIME(st.st_mtim);
+              sub->watcher->mEvents.update(sub->path);
+            }
+          }
+        }
+      }
+    }
+
+    for (auto it = watchers.begin(); it != watchers.end(); it++) {
+      (*it)->notify();
+    }
+  }
+
+done:
+  close(mPipe[0]);
+  close(mPipe[1]);
+  mEndedSignal.notify();
+}
+
+KqueueBackend::~KqueueBackend() {
+  write(mPipe[1], "X", 1);
+  mEndedSignal.wait();
+}
+
+void KqueueBackend::subscribe(WatcherRef watcher) {
+  // Build a full directory tree recursively, and watch each directory.
+  std::shared_ptr<DirTree> tree = getTree(watcher);
+
+  for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) {
+    bool success = watchDir(watcher, it->second.path, tree);
+    if (!success) {
+      throw WatcherError(std::string("error watching " + watcher->mDir + ": " + strerror(errno)), watcher);
+    }
+  }
+}
+
+bool KqueueBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree) {
+  if (watcher->isIgnored(path)) {
+    return false;
+  }
+
+  DirEntry *entry = tree->find(path);
+  if (!entry) {
+    return false;
+  }
+
+  KqueueSubscription sub = {
+    .watcher = watcher,
+    .path = path,
+    .tree = tree
+  };
+
+  if (!entry->state) {
+    int fd = open(path.c_str(), O_EVTONLY);
+    if (fd <= 0) {
+      return false;
+    }
+
+    struct kevent event;
+    EV_SET(
+      &event,
+      fd,
+      EVFILT_VNODE,
+      EV_ADD | EV_CLEAR | EV_ENABLE,
+      NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
+      0,
+      0
+    );
+
+    if (kevent(mKqueue, &event, 1, NULL, 0, 0)) {
+      close(fd);
+      return false;
+    }
+
+    entry->state = (void *)(size_t)fd;
+    mFdToEntry.emplace(fd, entry);
+  }
+
+  sub.fd = (int)(size_t)entry->state;
+  mSubscriptions.emplace(path, sub);
+  return true;
+}
+
+std::vector<KqueueSubscription *> KqueueBackend::findSubscriptions(std::string &path) {
+  // Find the subscriptions affected by this path.
+  // Copy pointers to them into a vector so that modifying mSubscriptions doesn't invalidate the iterator.
+  auto range = mSubscriptions.equal_range(path);
+  std::vector<KqueueSubscription *> subs;
+  for (auto it = range.first; it != range.second; it++) {
+    subs.push_back(&it->second);
+  }
+
+  return subs;
+}
+
+bool KqueueBackend::compareDir(int fd, std::string &path, std::unordered_set<WatcherRef> &watchers) {
+  // macOS doesn't support fdclosedir, so we have to duplicate the file descriptor
+  // to ensure the closedir doesn't also stop watching.
+  #if __APPLE__
+    fd = dup(fd);
+  #endif
+
+  DIR *dir = fdopendir(fd);
+  if (dir == NULL) {
+    return false;
+  }
+
+  // fdopendir doesn't rewind to the beginning.
+  rewinddir(dir);
+
+  std::vector<KqueueSubscription *> subs = findSubscriptions(path);
+  std::string dirStart = path + DIR_SEP;
+
+  std::unordered_set<std::shared_ptr<DirTree>> trees;
+  for (auto it = subs.begin(); it != subs.end(); it++) {
+    trees.emplace((*it)->tree);
+  }
+
+  std::unordered_set<std::string> entries;
+  struct dirent *entry;
+  while ((entry = readdir(dir))) {
+    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+      continue;
+    }
+
+    std::string fullpath = dirStart + entry->d_name;
+    entries.emplace(fullpath);
+
+    for (auto it = trees.begin(); it != trees.end(); it++) {
+      std::shared_ptr<DirTree> tree = *it;
+      if (!tree->find(fullpath)) {
+        struct stat st;
+        fstatat(fd, entry->d_name, &st, AT_SYMLINK_NOFOLLOW);
+        tree->add(fullpath, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode));
+
+        // Notify all watchers with the same tree.
+        for (auto i = subs.begin(); i != subs.end(); i++) {
+          KqueueSubscription *sub = *i;
+          if (sub->tree == tree) {
+            if (sub->watcher->isIgnored(fullpath)) {
+              continue;
+            }
+
+            sub->watcher->mEvents.create(fullpath);
+            watchers.emplace(sub->watcher);
+
+            bool success = watchDir(sub->watcher, fullpath, sub->tree);
+            if (!success) {
+              sub->tree->remove(fullpath);
+              return false;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (auto it = trees.begin(); it != trees.end(); it++) {
+    std::shared_ptr<DirTree> tree = *it;
+    for (auto entry = tree->entries.begin(); entry != tree->entries.end();) {
+
+      if (
+        entry->first.rfind(dirStart, 0) == 0 &&
+        entry->first.find(DIR_SEP, dirStart.length()) == std::string::npos &&
+        entries.count(entry->first) == 0
+      ) {
+        // Notify all watchers with the same tree.
+        for (auto i = subs.begin(); i != subs.end(); i++) {
+          if ((*i)->tree == tree) {
+            KqueueSubscription *sub = *i;
+            if (!sub->watcher->isIgnored(entry->first)) {
+              sub->watcher->mEvents.remove(entry->first);
+              watchers.emplace(sub->watcher);
+            }
+          }
+        }
+
+        mFdToEntry.erase((int)(size_t)entry->second.state);
+        mSubscriptions.erase(entry->first);
+        entry = tree->entries.erase(entry);
+      } else {
+        entry++;
+      }
+    }
+  }
+
+  #if __APPLE__
+    closedir(dir);
+  #else
+    fdclosedir(dir);
+  #endif
+
+  return true;
+}
+
+void KqueueBackend::unsubscribe(WatcherRef watcher) {
+  // Find any subscriptions pointing to this watcher, and remove them.
+  for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) {
+    if (it->second.watcher.get() == watcher.get()) {
+      if (mSubscriptions.count(it->first) == 1) {
+        // Closing the file descriptor automatically unwatches it in the kqueue.
+        close(it->second.fd);
+        mFdToEntry.erase(it->second.fd);
+      }
+
+      it = mSubscriptions.erase(it);
+    } else {
+      it++;
+    }
+  }
+}

node_modules/@parcel/watcher/src/kqueue/KqueueBackend.hh

@@ -0,0 +1,35 @@
+#ifndef KQUEUE_H
+#define KQUEUE_H
+
+#include <unordered_map>
+#include <sys/event.h>
+#include "../shared/BruteForceBackend.hh"
+#include "../DirTree.hh"
+#include "../Signal.hh"
+
+struct KqueueSubscription {
+  WatcherRef watcher;
+  std::string path;
+  std::shared_ptr<DirTree> tree;
+  int fd;
+};
+
+class KqueueBackend : public BruteForceBackend {
+public:
+  void start() override;
+  ~KqueueBackend();
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+private:
+  int mKqueue;
+  int mPipe[2];
+  std::unordered_multimap<std::string, KqueueSubscription> mSubscriptions;
+  std::unordered_map<int, DirEntry *> mFdToEntry;
+  Signal mEndedSignal;
+
+  bool watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree);
+  bool compareDir(int fd, std::string &dir, std::unordered_set<WatcherRef> &watchers);
+  std::vector<KqueueSubscription *> findSubscriptions(std::string &path);
+};
+
+#endif

node_modules/@parcel/watcher/src/linux/InotifyBackend.cc

@@ -0,0 +1,232 @@
+#include <memory>
+#include <poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include "InotifyBackend.hh"
+
+#define INOTIFY_MASK \
+  IN_ATTRIB | IN_CREATE | IN_DELETE | \
+  IN_DELETE_SELF | IN_MODIFY | IN_MOVE_SELF | IN_MOVED_FROM | \
+  IN_MOVED_TO | IN_DONT_FOLLOW | IN_ONLYDIR | IN_EXCL_UNLINK
+#define BUFFER_SIZE 8192
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+
+void InotifyBackend::start() {
+  // Create a pipe that we will write to when we want to end the thread.
+  int err = pipe2(mPipe, O_CLOEXEC | O_NONBLOCK);
+  if (err == -1) {
+    throw std::runtime_error(std::string("Unable to open pipe: ") + strerror(errno));
+  }
+
+  // Init inotify file descriptor.
+  mInotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+  if (mInotify == -1) {
+    throw std::runtime_error(std::string("Unable to initialize inotify: ") + strerror(errno));
+  }
+
+  pollfd pollfds[2];
+  pollfds[0].fd = mPipe[0];
+  pollfds[0].events = POLLIN;
+  pollfds[0].revents = 0;
+  pollfds[1].fd = mInotify;
+  pollfds[1].events = POLLIN;
+  pollfds[1].revents = 0;
+
+  notifyStarted();
+
+  // Loop until we get an event from the pipe.
+  while (true) {
+    int result = poll(pollfds, 2, 500);
+    if (result < 0) {
+      throw std::runtime_error(std::string("Unable to poll: ") + strerror(errno));
+    }
+
+    if (pollfds[0].revents) {
+      break;
+    }
+
+    if (pollfds[1].revents) {
+      handleEvents();
+    }
+  }
+
+  close(mPipe[0]);
+  close(mPipe[1]);
+  close(mInotify);
+
+  mEndedSignal.notify();
+}
+
+InotifyBackend::~InotifyBackend() {
+  write(mPipe[1], "X", 1);
+  mEndedSignal.wait();
+}
+
+// This function is called by Backend::watch which takes a lock on mMutex
+void InotifyBackend::subscribe(WatcherRef watcher) {
+  // Build a full directory tree recursively, and watch each directory.
+  std::shared_ptr<DirTree> tree = getTree(watcher);
+
+  for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) {
+    if (it->second.isDir) {
+      bool success = watchDir(watcher, it->second.path, tree);
+      if (!success) {
+        throw WatcherError(std::string("inotify_add_watch on '") + it->second.path + std::string("' failed: ") + strerror(errno), watcher);
+      }
+    }
+  }
+}
+
+bool InotifyBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree) {
+  int wd = inotify_add_watch(mInotify, path.c_str(), INOTIFY_MASK);
+  if (wd == -1) {
+    return false;
+  }
+
+  std::shared_ptr<InotifySubscription> sub = std::make_shared<InotifySubscription>();
+  sub->tree = tree;
+  sub->path = path;
+  sub->watcher = watcher;
+  mSubscriptions.emplace(wd, sub);
+
+  return true;
+}
+
+void InotifyBackend::handleEvents() {
+  char buf[BUFFER_SIZE] __attribute__ ((aligned(__alignof__(struct inotify_event))));;
+  struct inotify_event *event;
+
+  // Track all of the watchers that are touched so we can notify them at the end of the events.
+  std::unordered_set<WatcherRef> watchers;
+
+  while (true) {
+    int n = read(mInotify, &buf, BUFFER_SIZE);
+    if (n < 0) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        break;
+      }
+
+      throw std::runtime_error(std::string("Error reading from inotify: ") + strerror(errno));
+    }
+
+    if (n == 0) {
+      break;
+    }
+
+    for (char *ptr = buf; ptr < buf + n; ptr += sizeof(*event) + event->len) {
+      event = (struct inotify_event *)ptr;
+
+      if ((event->mask & IN_Q_OVERFLOW) == IN_Q_OVERFLOW) {
+        // overflow
+        continue;
+      }
+
+      handleEvent(event, watchers);
+    }
+  }
+
+  for (auto it = watchers.begin(); it != watchers.end(); it++) {
+    (*it)->notify();
+  }
+}
+
+void InotifyBackend::handleEvent(struct inotify_event *event, std::unordered_set<WatcherRef> &watchers) {
+  std::unique_lock<std::mutex> lock(mMutex);
+
+  // Find the subscriptions for this watch descriptor
+  auto range = mSubscriptions.equal_range(event->wd);
+  std::unordered_set<std::shared_ptr<InotifySubscription>> set;
+  for (auto it = range.first; it != range.second; it++) {
+    set.insert(it->second);
+  }
+
+  for (auto it = set.begin(); it != set.end(); it++) {
+    if (handleSubscription(event, *it)) {
+      watchers.insert((*it)->watcher);
+    }
+  }
+}
+
+bool InotifyBackend::handleSubscription(struct inotify_event *event, std::shared_ptr<InotifySubscription> sub) {
+  // Build full path and check if its in our ignore list.
+  std::shared_ptr<Watcher> watcher = sub->watcher;
+  std::string path = std::string(sub->path);
+  bool isDir = event->mask & IN_ISDIR;
+
+  if (event->len > 0) {
+    path += "/" + std::string(event->name);
+  }
+
+  if (watcher->isIgnored(path)) {
+    return false;
+  }
+
+  // If this is a create, check if it's a directory and start watching if it is.
+  // In any case, keep the directory tree up to date.
+  if (event->mask & (IN_CREATE | IN_MOVED_TO)) {
+    watcher->mEvents.create(path);
+
+    struct stat st;
+    // Use lstat to avoid resolving symbolic links that we cannot watch anyway
+    // https://github.com/parcel-bundler/watcher/issues/76
+    lstat(path.c_str(), &st);
+    DirEntry *entry = sub->tree->add(path, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode));
+
+    if (entry->isDir) {
+      bool success = watchDir(watcher, path, sub->tree);
+      if (!success) {
+        sub->tree->remove(path);
+        return false;
+      }
+    }
+  } else if (event->mask & (IN_MODIFY | IN_ATTRIB)) {
+    watcher->mEvents.update(path);
+
+    struct stat st;
+    stat(path.c_str(), &st);
+    sub->tree->update(path, CONVERT_TIME(st.st_mtim));
+  } else if (event->mask & (IN_DELETE | IN_DELETE_SELF | IN_MOVED_FROM | IN_MOVE_SELF)) {
+    bool isSelfEvent = (event->mask & (IN_DELETE_SELF | IN_MOVE_SELF));
+    // Ignore delete/move self events unless this is the recursive watch root
+    if (isSelfEvent && path != watcher->mDir) {
+      return false;
+    }
+
+    // If the entry being deleted/moved is a directory, remove it from the list of subscriptions
+    // XXX: self events don't have the IN_ISDIR mask
+    if (isSelfEvent || isDir) {
+      for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) {
+        if (it->second->path == path) {
+          it = mSubscriptions.erase(it);
+        } else {
+          ++it;
+        }
+      }
+    }
+
+    watcher->mEvents.remove(path);
+    sub->tree->remove(path);
+  }
+
+  return true;
+}
+
+// This function is called by Backend::unwatch which takes a lock on mMutex
+void InotifyBackend::unsubscribe(WatcherRef watcher) {
+  // Find any subscriptions pointing to this watcher, and remove them.
+  for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) {
+    if (it->second->watcher.get() == watcher.get()) {
+      if (mSubscriptions.count(it->first) == 1) {
+        int err = inotify_rm_watch(mInotify, it->first);
+        if (err == -1) {
+          throw WatcherError(std::string("Unable to remove watcher: ") + strerror(errno), watcher);
+        }
+      }
+
+      it = mSubscriptions.erase(it);
+    } else {
+      it++;
+    }
+  }
+}

node_modules/@parcel/watcher/src/linux/InotifyBackend.hh

@@ -0,0 +1,34 @@
+#ifndef INOTIFY_H
+#define INOTIFY_H
+
+#include <unordered_map>
+#include <sys/inotify.h>
+#include "../shared/BruteForceBackend.hh"
+#include "../DirTree.hh"
+#include "../Signal.hh"
+
+struct InotifySubscription {
+  std::shared_ptr<DirTree> tree;
+  std::string path;
+  WatcherRef watcher;
+};
+
+class InotifyBackend : public BruteForceBackend {
+public:
+  void start() override;
+  ~InotifyBackend();
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+private:
+  int mPipe[2];
+  int mInotify;
+  std::unordered_multimap<int, std::shared_ptr<InotifySubscription>> mSubscriptions;
+  Signal mEndedSignal;
+
+  bool watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree);
+  void handleEvents();
+  void handleEvent(struct inotify_event *event, std::unordered_set<WatcherRef> &watchers);
+  bool handleSubscription(struct inotify_event *event, std::shared_ptr<InotifySubscription> sub);
+};
+
+#endif

node_modules/@parcel/watcher/src/macos/FSEventsBackend.cc

@@ -0,0 +1,338 @@
+#include <CoreServices/CoreServices.h>
+#include <sys/stat.h>
+#include <string>
+#include <fstream>
+#include <unordered_set>
+#include "../Event.hh"
+#include "../Backend.hh"
+#include "./FSEventsBackend.hh"
+#include "../Watcher.hh"
+
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+#define IGNORED_FLAGS (kFSEventStreamEventFlagItemIsHardlink | kFSEventStreamEventFlagItemIsLastHardlink | kFSEventStreamEventFlagItemIsSymlink | kFSEventStreamEventFlagItemIsDir | kFSEventStreamEventFlagItemIsFile)
+
+void stopStream(FSEventStreamRef stream, CFRunLoopRef runLoop) {
+  FSEventStreamStop(stream);
+  FSEventStreamUnscheduleFromRunLoop(stream, runLoop, kCFRunLoopDefaultMode);
+  FSEventStreamInvalidate(stream);
+  FSEventStreamRelease(stream);
+}
+
+// macOS has a case insensitive file system by default. In order to detect
+// file renames that only affect case, we need to get the canonical path
+// and compare it with the input path to determine if a file was created or deleted.
+bool pathExists(char *path) {
+  int fd = open(path, O_RDONLY | O_SYMLINK);
+  if (fd == -1) {
+    return false;
+  }
+
+  char buf[PATH_MAX];
+  if (fcntl(fd, F_GETPATH, buf) == -1) {
+    close(fd);
+    return false;
+  }
+
+  bool res = strncmp(path, buf, PATH_MAX) == 0;
+  close(fd);
+  return res;
+}
+
+class State: public WatcherState {
+public:
+  FSEventStreamRef stream;
+  std::shared_ptr<DirTree> tree;
+  uint64_t since;
+};
+
+void FSEventsCallback(
+  ConstFSEventStreamRef streamRef,
+  void *clientCallBackInfo,
+  size_t numEvents,
+  void *eventPaths,
+  const FSEventStreamEventFlags eventFlags[],
+  const FSEventStreamEventId eventIds[]
+) {
+  char **paths = (char **)eventPaths;
+  std::shared_ptr<Watcher>& watcher = *static_cast<std::shared_ptr<Watcher> *>(clientCallBackInfo);
+
+  EventList& list = watcher->mEvents;
+  if (watcher->state == nullptr) {
+      return;
+  }
+
+  auto stateGuard = watcher->state;
+  auto* state = static_cast<State*>(stateGuard.get());
+  uint64_t since = state->since;
+  bool deletedRoot = false;
+
+  for (size_t i = 0; i < numEvents; ++i) {
+    bool isCreated = (eventFlags[i] & kFSEventStreamEventFlagItemCreated) == kFSEventStreamEventFlagItemCreated;
+    bool isRemoved = (eventFlags[i] & kFSEventStreamEventFlagItemRemoved) == kFSEventStreamEventFlagItemRemoved;
+    bool isModified = (eventFlags[i] & kFSEventStreamEventFlagItemModified) == kFSEventStreamEventFlagItemModified ||
+                      (eventFlags[i] & kFSEventStreamEventFlagItemInodeMetaMod) == kFSEventStreamEventFlagItemInodeMetaMod ||
+                      (eventFlags[i] & kFSEventStreamEventFlagItemFinderInfoMod) == kFSEventStreamEventFlagItemFinderInfoMod ||
+                      (eventFlags[i] & kFSEventStreamEventFlagItemChangeOwner) == kFSEventStreamEventFlagItemChangeOwner ||
+                      (eventFlags[i] & kFSEventStreamEventFlagItemXattrMod) == kFSEventStreamEventFlagItemXattrMod;
+    bool isRenamed = (eventFlags[i] & kFSEventStreamEventFlagItemRenamed) == kFSEventStreamEventFlagItemRenamed;
+    bool isDone = (eventFlags[i] & kFSEventStreamEventFlagHistoryDone) == kFSEventStreamEventFlagHistoryDone;
+    bool isDir = (eventFlags[i] & kFSEventStreamEventFlagItemIsDir) == kFSEventStreamEventFlagItemIsDir;
+
+
+    if (eventFlags[i] & kFSEventStreamEventFlagMustScanSubDirs) {
+      if (eventFlags[i] & kFSEventStreamEventFlagUserDropped) {
+        list.error("Events were dropped by the FSEvents client. File system must be re-scanned.");
+      } else if (eventFlags[i] & kFSEventStreamEventFlagKernelDropped) {
+        list.error("Events were dropped by the kernel. File system must be re-scanned.");
+      } else {
+        list.error("Too many events. File system must be re-scanned.");
+      }
+    }
+
+    if (isDone) {
+      watcher->notify();
+      break;
+    }
+
+    auto ignoredFlags = IGNORED_FLAGS;
+    if (__builtin_available(macOS 10.13, *)) {
+      ignoredFlags |= kFSEventStreamEventFlagItemCloned;
+    }
+
+    // If we don't care about any of the flags that are set, ignore this event.
+    if ((eventFlags[i] & ~ignoredFlags) == 0) {
+      continue;
+    }
+
+    // FSEvents exclusion paths only apply to files, not directories.
+    if (watcher->isIgnored(paths[i])) {
+      continue;
+    }
+
+    // Handle unambiguous events first
+    if (isCreated && !(isRemoved || isModified || isRenamed)) {
+      state->tree->add(paths[i], 0, isDir);
+      list.create(paths[i]);
+    } else if (isRemoved && !(isCreated || isModified || isRenamed)) {
+      state->tree->remove(paths[i]);
+      list.remove(paths[i]);
+      if (paths[i] == watcher->mDir) {
+        deletedRoot = true;
+      }
+    } else if (isModified && !(isCreated || isRemoved || isRenamed)) {
+      struct stat file;
+      if (stat(paths[i], &file)) {
+        continue;
+      }
+
+      // Ignore if mtime is the same as the last event.
+      // This prevents duplicate events from being emitted.
+      // If tv_nsec is zero, the file system probably only has second-level
+      // granularity so allow the even through in that case.
+      uint64_t mtime = CONVERT_TIME(file.st_mtimespec);
+      DirEntry *entry = state->tree->find(paths[i]);
+      if (entry && mtime == entry->mtime && file.st_mtimespec.tv_nsec != 0) {
+        continue;
+      }
+
+      if (entry) {
+        // Update mtime.
+        entry->mtime = mtime;
+      } else {
+        // Add to tree if this path has not been discovered yet.
+        state->tree->add(paths[i], mtime, S_ISDIR(file.st_mode));
+      }
+
+      list.update(paths[i]);
+    } else {
+      // If multiple flags were set, then we need to call `stat` to determine if the file really exists.
+      // This helps disambiguate creates, updates, and deletes.
+      struct stat file;
+      if (stat(paths[i], &file) || !pathExists(paths[i])) {
+        // File does not exist, so we have to assume it was removed. This is not exact since the
+        // flags set by fsevents get coalesced together (e.g. created & deleted), so there is no way to
+        // know whether the create and delete both happened since our snapshot (in which case
+        // we'd rather ignore this event completely). This will result in some extra delete events
+        // being emitted for files we don't know about, but that is the best we can do.
+        state->tree->remove(paths[i]);
+        list.remove(paths[i]);
+        if (paths[i] == watcher->mDir) {
+          deletedRoot = true;
+        }
+        continue;
+      }
+
+      // If the file was modified, and existed before, then this is an update, otherwise a create.
+      uint64_t ctime = CONVERT_TIME(file.st_birthtimespec);
+      uint64_t mtime = CONVERT_TIME(file.st_mtimespec);
+      DirEntry *entry = !since ? state->tree->find(paths[i]) : NULL;
+      if (entry && entry->mtime == mtime && file.st_mtimespec.tv_nsec != 0) {
+        continue;
+      }
+
+      // Some mounted file systems report a creation time of 0/unix epoch which we special case.
+      if (isModified && (entry || (ctime <= since && ctime != 0))) {
+        state->tree->update(paths[i], mtime);
+        list.update(paths[i]);
+      } else {
+        state->tree->add(paths[i], mtime, S_ISDIR(file.st_mode));
+        list.create(paths[i]);
+      }
+    }
+  }
+
+  if (!since) {
+    watcher->notify();
+  }
+
+  // Stop watching if the root directory was deleted.
+  if (deletedRoot) {
+    stopStream((FSEventStreamRef)streamRef, CFRunLoopGetCurrent());
+    watcher->state = nullptr;
+  }
+}
+
+void checkWatcher(WatcherRef watcher) {
+  struct stat file;
+  if (stat(watcher->mDir.c_str(), &file)) {
+    throw WatcherError(strerror(errno), watcher);
+  }
+
+  if (!S_ISDIR(file.st_mode)) {
+    throw WatcherError(strerror(ENOTDIR), watcher);
+  }
+}
+
+void FSEventsBackend::startStream(WatcherRef watcher, FSEventStreamEventId id) {
+  checkWatcher(watcher);
+
+  CFAbsoluteTime latency = 0.001;
+  CFStringRef fileWatchPath = CFStringCreateWithCString(
+    NULL,
+    watcher->mDir.c_str(),
+    kCFStringEncodingUTF8
+  );
+
+  CFArrayRef pathsToWatch = CFArrayCreate(
+    NULL,
+    (const void **)&fileWatchPath,
+    1,
+    NULL
+  );
+
+  // Make a watcher reference we can pass into the callback. This ensures bumped ref-count.
+  std::shared_ptr<Watcher>* callbackWatcher = new std::shared_ptr<Watcher> (watcher);
+  FSEventStreamContext callbackInfo {0, static_cast<void*> (callbackWatcher), nullptr, nullptr, nullptr};
+  FSEventStreamRef stream = FSEventStreamCreate(
+    NULL,
+    &FSEventsCallback,
+    &callbackInfo,
+    pathsToWatch,
+    id,
+    latency,
+    kFSEventStreamCreateFlagFileEvents
+  );
+
+  CFMutableArrayRef exclusions = CFArrayCreateMutable(NULL, watcher->mIgnorePaths.size(), NULL);
+  for (auto it = watcher->mIgnorePaths.begin(); it != watcher->mIgnorePaths.end(); it++) {
+    CFStringRef path = CFStringCreateWithCString(
+      NULL,
+      it->c_str(),
+      kCFStringEncodingUTF8
+    );
+
+    CFArrayAppendValue(exclusions, (const void *)path);
+  }
+
+  FSEventStreamSetExclusionPaths(stream, exclusions);
+
+  FSEventStreamScheduleWithRunLoop(stream, mRunLoop, kCFRunLoopDefaultMode);
+  bool started = FSEventStreamStart(stream);
+
+  CFRelease(pathsToWatch);
+  CFRelease(fileWatchPath);
+
+  if (!started) {
+    FSEventStreamRelease(stream);
+    throw WatcherError("Error starting FSEvents stream", watcher);
+  }
+
+  auto stateGuard = watcher->state;
+  State* s = static_cast<State*>(stateGuard.get());
+  s->tree = std::make_shared<DirTree>(watcher->mDir);
+  s->stream = stream;
+}
+
+void FSEventsBackend::start() {
+  mRunLoop = CFRunLoopGetCurrent();
+  CFRetain(mRunLoop);
+
+  // Unlock once run loop has started.
+  CFRunLoopPerformBlock(mRunLoop, kCFRunLoopDefaultMode, ^ {
+    notifyStarted();
+  });
+
+  CFRunLoopWakeUp(mRunLoop);
+  CFRunLoopRun();
+}
+
+FSEventsBackend::~FSEventsBackend() {
+  std::unique_lock<std::mutex> lock(mMutex);
+  CFRunLoopStop(mRunLoop);
+  CFRelease(mRunLoop);
+}
+
+void FSEventsBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  checkWatcher(watcher);
+
+  FSEventStreamEventId id = FSEventsGetCurrentEventId();
+  std::ofstream ofs(*snapshotPath);
+  ofs << id;
+  ofs << "\n";
+
+  struct timespec now;
+  clock_gettime(CLOCK_REALTIME, &now);
+  ofs << CONVERT_TIME(now);
+}
+
+void FSEventsBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  std::ifstream ifs(*snapshotPath);
+  if (ifs.fail()) {
+    return;
+  }
+
+  FSEventStreamEventId id;
+  uint64_t since;
+  ifs >> id;
+  ifs >> since;
+
+  auto s = std::make_shared<State>();
+  s->since = since;
+  watcher->state = s;
+
+  startStream(watcher, id);
+  watcher->wait();
+  stopStream(s->stream, mRunLoop);
+
+  watcher->state = nullptr;
+}
+
+// This function is called by Backend::watch which takes a lock on mMutex
+void FSEventsBackend::subscribe(WatcherRef watcher) {
+  auto s = std::make_shared<State>();
+  s->since = 0;
+  watcher->state = s;
+  startStream(watcher, kFSEventStreamEventIdSinceNow);
+}
+
+// This function is called by Backend::unwatch which takes a lock on mMutex
+void FSEventsBackend::unsubscribe(WatcherRef watcher) {
+  auto stateGuard = watcher->state;
+  State* s = static_cast<State*>(stateGuard.get());
+  if (s != nullptr) {
+    stopStream(s->stream, mRunLoop);
+    watcher->state = nullptr;
+  }
+}

node_modules/@parcel/watcher/src/macos/FSEventsBackend.hh

@@ -0,0 +1,20 @@
+#ifndef FS_EVENTS_H
+#define FS_EVENTS_H
+
+#include <CoreServices/CoreServices.h>
+#include "../Backend.hh"
+
+class FSEventsBackend : public Backend {
+public:
+  void start() override;
+  ~FSEventsBackend();
+  void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override;
+  void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override;
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+private:
+  void startStream(WatcherRef watcher, FSEventStreamEventId id);
+  CFRunLoopRef mRunLoop;
+};
+
+#endif

node_modules/@parcel/watcher/src/shared/BruteForceBackend.cc

@@ -0,0 +1,41 @@
+#include <string>
+#include "../DirTree.hh"
+#include "../Event.hh"
+#include "./BruteForceBackend.hh"
+
+std::shared_ptr<DirTree> BruteForceBackend::getTree(WatcherRef watcher, bool shouldRead) {
+  auto tree = DirTree::getCached(watcher->mDir);
+
+  // If the tree is not complete, read it if needed.
+  if (!tree->isComplete && shouldRead) {
+    readTree(watcher, tree);
+    tree->isComplete = true;
+  }
+
+  return tree;
+}
+
+void BruteForceBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  auto tree = getTree(watcher);
+  FILE *f = fopen(snapshotPath->c_str(), "w");
+  if (!f) {
+    throw std::runtime_error(std::string("Unable to open snapshot file: ") + strerror(errno));
+  }
+
+  tree->write(f);
+  fclose(f);
+}
+
+void BruteForceBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  FILE *f = fopen(snapshotPath->c_str(), "r");
+  if (!f) {
+    throw std::runtime_error(std::string("Unable to open snapshot file: ") + strerror(errno));
+  }
+
+  DirTree snapshot{watcher->mDir, f};
+  auto now = getTree(watcher);
+  now->getChanges(&snapshot, watcher->mEvents);
+  fclose(f);
+}

node_modules/@parcel/watcher/src/shared/BruteForceBackend.hh

@@ -0,0 +1,25 @@
+#ifndef BRUTE_FORCE_H
+#define BRUTE_FORCE_H
+
+#include "../Backend.hh"
+#include "../DirTree.hh"
+#include "../Watcher.hh"
+
+class BruteForceBackend : public Backend {
+public:
+  void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override;
+  void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override;
+  void subscribe(WatcherRef watcher) override {
+    throw "Brute force backend doesn't support subscriptions.";
+  }
+
+  void unsubscribe(WatcherRef watcher) override {
+    throw "Brute force backend doesn't support subscriptions.";
+  }
+
+  std::shared_ptr<DirTree> getTree(WatcherRef watcher, bool shouldRead = true);
+private:
+  void readTree(WatcherRef watcher, std::shared_ptr<DirTree> tree);
+};
+
+#endif

node_modules/@parcel/watcher/src/unix/fts.cc

@@ -0,0 +1,50 @@
+#include <string>
+
+// weird error on linux
+#ifdef __THROW
+#undef __THROW
+#endif
+#define __THROW
+
+#include <fts.h>
+#include <sys/stat.h>
+#include "../DirTree.hh"
+#include "../shared/BruteForceBackend.hh"
+
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+#if __APPLE__
+#define st_mtim st_mtimespec
+#endif
+
+void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr<DirTree> tree) {
+  char *paths[2] {(char *)watcher->mDir.c_str(), NULL};
+  FTS *fts = fts_open(paths, FTS_NOCHDIR | FTS_PHYSICAL, NULL);
+  if (!fts) {
+    throw WatcherError(strerror(errno), watcher);
+  }
+
+  FTSENT *node;
+  bool isRoot = true;
+
+  while ((node = fts_read(fts)) != NULL) {
+    if (node->fts_errno) {
+      fts_close(fts);
+      throw WatcherError(strerror(node->fts_errno), watcher);
+    }
+
+    if (isRoot && !(node->fts_info & FTS_D)) {
+      fts_close(fts);
+      throw WatcherError(strerror(ENOTDIR), watcher);
+    }
+
+    if (watcher->isIgnored(std::string(node->fts_path))) {
+      fts_set(fts, node, FTS_SKIP);
+      continue;
+    }
+
+    tree->add(node->fts_path, CONVERT_TIME(node->fts_statp->st_mtim), (node->fts_info & FTS_D) == FTS_D);
+    isRoot = false;
+  }
+
+  fts_close(fts);
+}

node_modules/@parcel/watcher/src/unix/legacy.cc

@@ -0,0 +1,77 @@
+#include <string>
+
+// weird error on linux
+#ifdef __THROW
+#undef __THROW
+#endif
+#define __THROW
+
+#ifdef _LIBC
+# include <include/sys/stat.h>
+#else
+# include <sys/stat.h>
+#endif
+#include <dirent.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "../DirTree.hh"
+#include "../shared/BruteForceBackend.hh"
+
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+#if __APPLE__
+#define st_mtim st_mtimespec
+#endif
+#define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
+
+void iterateDir(WatcherRef watcher, const std::shared_ptr <DirTree> tree, const char *relative, int parent_fd, const std::string &dirname) {
+    int open_flags = (O_RDONLY | O_CLOEXEC | O_DIRECTORY | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW);
+    int new_fd = openat(parent_fd, relative, open_flags);
+    if (new_fd == -1) {
+        if (errno == EACCES) {
+            return; // ignore insufficient permissions
+        }
+
+        throw WatcherError(strerror(errno), watcher);
+    }
+
+    struct stat rootAttributes;
+    fstatat(new_fd, ".", &rootAttributes, AT_SYMLINK_NOFOLLOW);
+    tree->add(dirname, CONVERT_TIME(rootAttributes.st_mtim), true);
+
+    if (DIR *dir = fdopendir(new_fd)) {
+        while (struct dirent *ent = (errno = 0, readdir(dir))) {
+            if (ISDOT(ent->d_name)) continue;
+
+            std::string fullPath = dirname + "/" + ent->d_name;
+
+            if (!watcher->isIgnored(fullPath)) {
+                struct stat attrib;
+                fstatat(new_fd, ent->d_name, &attrib, AT_SYMLINK_NOFOLLOW);
+                bool isDir = ent->d_type == DT_DIR;
+
+                if (isDir) {
+                    iterateDir(watcher, tree, ent->d_name, new_fd, fullPath);
+                } else {
+                    tree->add(fullPath, CONVERT_TIME(attrib.st_mtim), isDir);
+                }
+            }
+        }
+
+        closedir(dir);
+    } else {
+        close(new_fd);
+    }
+
+    if (errno) {
+        throw WatcherError(strerror(errno), watcher);
+    }
+}
+
+void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr <DirTree> tree) {
+    int fd = open(watcher->mDir.c_str(), O_RDONLY);
+    if (fd) {
+        iterateDir(watcher, tree, ".", fd, watcher->mDir);
+        close(fd);
+    }
+}

node_modules/@parcel/watcher/src/wasm/WasmBackend.cc

@@ -0,0 +1,132 @@
+#include <sys/stat.h>
+#include "WasmBackend.hh"
+
+#define CONVERT_TIME(ts) ((uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec)
+
+void WasmBackend::start() {
+  notifyStarted();
+}
+
+void WasmBackend::subscribe(WatcherRef watcher) {
+  // Build a full directory tree recursively, and watch each directory.
+  std::shared_ptr<DirTree> tree = getTree(watcher);
+
+  for (auto it = tree->entries.begin(); it != tree->entries.end(); it++) {
+    if (it->second.isDir) {
+      watchDir(watcher, it->second.path, tree);
+    }
+  }
+}
+
+void WasmBackend::watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree) {
+  int wd = wasm_backend_add_watch(path.c_str(), (void *)this);
+  std::shared_ptr<WasmSubscription> sub = std::make_shared<WasmSubscription>();
+  sub->tree = tree;
+  sub->path = path;
+  sub->watcher = watcher;
+  mSubscriptions.emplace(wd, sub);
+}
+
+extern "C" void wasm_backend_event_handler(void *backend, int wd, int type, char *filename) {
+  WasmBackend *b = (WasmBackend *)(backend);
+  b->handleEvent(wd, type, filename);
+}
+
+void WasmBackend::handleEvent(int wd, int type, char *filename) {
+  // Find the subscriptions for this watch descriptor
+  auto range = mSubscriptions.equal_range(wd);
+  std::unordered_set<std::shared_ptr<WasmSubscription>> set;
+  for (auto it = range.first; it != range.second; it++) {
+    set.insert(it->second);
+  }
+
+  for (auto it = set.begin(); it != set.end(); it++) {
+    if (handleSubscription(type, filename, *it)) {
+      (*it)->watcher->notify();
+    }
+  }
+}
+
+bool WasmBackend::handleSubscription(int type, char *filename, std::shared_ptr<WasmSubscription> sub) {
+  // Build full path and check if its in our ignore list.
+  WatcherRef watcher = sub->watcher;
+  std::string path = std::string(sub->path);
+
+  if (filename[0] != '\0') {
+    path += "/" + std::string(filename);
+  }
+
+  if (watcher->isIgnored(path)) {
+    return false;
+  }
+
+  if (type == 1) {
+    struct stat st;
+    stat(path.c_str(), &st);
+    sub->tree->update(path, CONVERT_TIME(st.st_mtim));
+    watcher->mEvents.update(path);
+  } else if (type == 2) {
+    // Determine if this is a create or delete depending on if the file exists or not.
+    struct stat st;
+    if (lstat(path.c_str(), &st)) {
+      // If the entry being deleted/moved is a directory, remove it from the list of subscriptions
+      DirEntry *entry = sub->tree->find(path);
+      if (!entry) {
+        return false;
+      }
+
+      if (entry->isDir) {
+        std::string pathStart = path + DIR_SEP;
+        for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) {
+          if (it->second->path == path || it->second->path.rfind(pathStart, 0) == 0) {
+            wasm_backend_remove_watch(it->first);
+            it = mSubscriptions.erase(it);
+          } else {
+            ++it;
+          }
+        }
+
+        // Remove all sub-entries
+        for (auto it = sub->tree->entries.begin(); it != sub->tree->entries.end();) {
+          if (it->first.rfind(pathStart, 0) == 0) {
+            watcher->mEvents.remove(it->first);
+            it = sub->tree->entries.erase(it);
+          } else {
+            it++;
+          }
+        }
+      }
+
+      watcher->mEvents.remove(path);
+      sub->tree->remove(path);
+    } else if (sub->tree->find(path)) {
+      sub->tree->update(path, CONVERT_TIME(st.st_mtim));
+      watcher->mEvents.update(path);
+    } else {
+      watcher->mEvents.create(path);
+
+      // If this is a create, check if it's a directory and start watching if it is.
+      DirEntry *entry = sub->tree->add(path, CONVERT_TIME(st.st_mtim), S_ISDIR(st.st_mode));
+      if (entry->isDir) {
+        watchDir(watcher, path, sub->tree);
+      }
+    }
+  }
+
+  return true;
+}
+
+void WasmBackend::unsubscribe(WatcherRef watcher) {
+  // Find any subscriptions pointing to this watcher, and remove them.
+  for (auto it = mSubscriptions.begin(); it != mSubscriptions.end();) {
+    if (it->second->watcher.get() == watcher.get()) {
+      if (mSubscriptions.count(it->first) == 1) {
+        wasm_backend_remove_watch(it->first);
+      }
+
+      it = mSubscriptions.erase(it);
+    } else {
+      it++;
+    }
+  }
+}

node_modules/@parcel/watcher/src/wasm/WasmBackend.hh

@@ -0,0 +1,34 @@
+#ifndef WASM_H
+#define WASM_H
+
+#include <unordered_map>
+#include "../shared/BruteForceBackend.hh"
+#include "../DirTree.hh"
+
+extern "C" {
+  int wasm_backend_add_watch(const char *filename, void *backend);
+  void wasm_backend_remove_watch(int wd);
+  void wasm_backend_event_handler(void *backend, int wd, int type, char *filename);
+};
+
+struct WasmSubscription {
+  std::shared_ptr<DirTree> tree;
+  std::string path;
+  WatcherRef watcher;
+};
+
+class WasmBackend : public BruteForceBackend {
+public:
+  void start() override;
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+  void handleEvent(int wd, int type, char *filename);
+private:
+  int mWasm;
+  std::unordered_multimap<int, std::shared_ptr<WasmSubscription>> mSubscriptions;
+
+  void watchDir(WatcherRef watcher, std::string path, std::shared_ptr<DirTree> tree);
+  bool handleSubscription(int type, char *filename, std::shared_ptr<WasmSubscription> sub);
+};
+
+#endif

node_modules/@parcel/watcher/src/wasm/include.h

@@ -0,0 +1,74 @@
+/*
+Copyright Node.js contributors. All rights reserved.
+
+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.
+*/
+
+// Node does not include the headers for these functions when compiling for WASM, so add them here.
+#ifdef __wasm32__
+extern "C" {
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_threadsafe_function(napi_env env,
+                                napi_value func,
+                                napi_value async_resource,
+                                napi_value async_resource_name,
+                                size_t max_queue_size,
+                                size_t initial_thread_count,
+                                void* thread_finalize_data,
+                                napi_finalize thread_finalize_cb,
+                                void* context,
+                                napi_threadsafe_function_call_js call_js_cb,
+                                napi_threadsafe_function* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context(
+    napi_threadsafe_function func, void** result);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_call_threadsafe_function(napi_threadsafe_function func,
+                              void* data,
+                              napi_threadsafe_function_call_mode is_blocking);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_acquire_threadsafe_function(napi_threadsafe_function func);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
+    napi_threadsafe_function func, napi_threadsafe_function_release_mode mode);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_async_work(napi_env env,
+                       napi_value async_resource,
+                       napi_value async_resource_name,
+                       napi_async_execute_callback execute,
+                       napi_async_complete_callback complete,
+                       void* data,
+                       napi_async_work* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
+                                                          napi_async_work work);
+NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(napi_env env,
+                                                         napi_async_work work);
+NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(napi_env env,
+                                                          napi_async_work work);
+}
+#endif

node_modules/@parcel/watcher/src/watchman/BSER.cc

@@ -0,0 +1,302 @@
+#include <stdint.h>
+#include "./BSER.hh"
+
+BSERType decodeType(std::istream &iss) {
+  int8_t type;
+  iss.read(reinterpret_cast<char*>(&type), sizeof(type));
+  return (BSERType) type;
+}
+
+void expectType(std::istream &iss, BSERType expected) {
+  BSERType got = decodeType(iss);
+  if (got != expected) {
+    throw std::runtime_error("Unexpected BSER type");
+  }
+}
+
+void encodeType(std::ostream &oss, BSERType type) {
+  int8_t t = (int8_t)type;
+  oss.write(reinterpret_cast<char*>(&t), sizeof(t));
+}
+
+template<typename T>
+class Value : public BSERValue {
+public:
+  T value;
+  Value(T val) {
+    value = val;
+  }
+
+  Value() {}
+};
+
+class BSERInteger : public Value<int64_t> {
+public:
+  BSERInteger(int64_t value) : Value(value) {}
+  BSERInteger(std::istream &iss) {
+    int8_t int8;
+    int16_t int16;
+    int32_t int32;
+    int64_t int64;
+
+    BSERType type = decodeType(iss);
+
+    switch (type) {
+      case BSER_INT8:
+        iss.read(reinterpret_cast<char*>(&int8), sizeof(int8));
+        value = int8;
+        break;
+      case BSER_INT16:
+        iss.read(reinterpret_cast<char*>(&int16), sizeof(int16));
+        value = int16;
+        break;
+      case BSER_INT32:
+        iss.read(reinterpret_cast<char*>(&int32), sizeof(int32));
+        value = int32;
+        break;
+      case BSER_INT64:
+        iss.read(reinterpret_cast<char*>(&int64), sizeof(int64));
+        value = int64;
+        break;
+      default:
+        throw std::runtime_error("Invalid BSER int type");
+    }
+  }
+
+  int64_t intValue() override {
+    return value;
+  }
+
+  void encode(std::ostream &oss) override {
+    if (value <= INT8_MAX) {
+      encodeType(oss, BSER_INT8);
+      int8_t v = (int8_t)value;
+      oss.write(reinterpret_cast<char*>(&v), sizeof(v));
+    } else if (value <= INT16_MAX) {
+      encodeType(oss, BSER_INT16);
+      int16_t v = (int16_t)value;
+      oss.write(reinterpret_cast<char*>(&v), sizeof(v));
+    } else if (value <= INT32_MAX) {
+      encodeType(oss, BSER_INT32);
+      int32_t v = (int32_t)value;
+      oss.write(reinterpret_cast<char*>(&v), sizeof(v));
+    } else {
+      encodeType(oss, BSER_INT64);
+      oss.write(reinterpret_cast<char*>(&value), sizeof(value));
+    }
+  }
+};
+
+class BSERArray : public Value<BSER::Array> {
+public:
+  BSERArray() : Value() {}
+  BSERArray(BSER::Array value) : Value(value) {}
+  BSERArray(std::istream &iss) {
+    expectType(iss, BSER_ARRAY);
+    int64_t len = BSERInteger(iss).intValue();
+    for (int64_t i = 0; i < len; i++) {
+      value.push_back(BSER(iss));
+    }
+  }
+  
+  BSER::Array arrayValue() override {
+    return value;
+  }
+
+  void encode(std::ostream &oss) override {
+    encodeType(oss, BSER_ARRAY);
+    BSERInteger(value.size()).encode(oss);
+    for (auto it = value.begin(); it != value.end(); it++) {
+      it->encode(oss);
+    }
+  }
+};
+
+class BSERString : public Value<std::string> {
+public:
+  BSERString(std::string value) : Value(value) {}
+  BSERString(std::istream &iss) {
+    expectType(iss, BSER_STRING);
+    int64_t len = BSERInteger(iss).intValue();
+    value.resize(len);
+    iss.read(&value[0], len);
+  }
+
+  std::string stringValue() override {
+    return value;
+  }
+
+  void encode(std::ostream &oss) override {
+    encodeType(oss, BSER_STRING);
+    BSERInteger(value.size()).encode(oss);
+    oss << value;
+  }
+};
+
+class BSERObject : public Value<BSER::Object> {
+public:
+  BSERObject() : Value() {}
+  BSERObject(BSER::Object value) : Value(value) {}
+  BSERObject(std::istream &iss) {
+    expectType(iss, BSER_OBJECT);
+    int64_t len = BSERInteger(iss).intValue();
+    for (int64_t i = 0; i < len; i++) {
+      auto key = BSERString(iss).stringValue();
+      auto val = BSER(iss);
+      value.emplace(key, val);
+    }
+  }
+
+  BSER::Object objectValue() override {
+    return value;
+  }
+
+  void encode(std::ostream &oss) override {
+    encodeType(oss, BSER_OBJECT);
+    BSERInteger(value.size()).encode(oss);
+    for (auto it = value.begin(); it != value.end(); it++) {
+      BSERString(it->first).encode(oss);
+      it->second.encode(oss);
+    }
+  }
+};
+
+class BSERDouble : public Value<double> {
+public:
+  BSERDouble(double value) : Value(value) {}
+  BSERDouble(std::istream &iss) {
+    expectType(iss, BSER_REAL);
+    iss.read(reinterpret_cast<char*>(&value), sizeof(value));
+  }
+
+  double doubleValue() override {
+    return value;
+  }
+
+  void encode(std::ostream &oss) override {
+    encodeType(oss, BSER_REAL);
+    oss.write(reinterpret_cast<char*>(&value), sizeof(value));
+  }
+};
+
+class BSERBoolean : public Value<bool> {
+public:
+  BSERBoolean(bool value) : Value(value) {}
+  bool boolValue() override { return value; }
+  void encode(std::ostream &oss) override {
+    int8_t t = value == true ? BSER_BOOL_TRUE : BSER_BOOL_FALSE;
+    oss.write(reinterpret_cast<char*>(&t), sizeof(t));
+  }
+};
+
+class BSERNull : public Value<bool> {
+public:
+  BSERNull() : Value(false) {}
+  void encode(std::ostream &oss) override {
+    encodeType(oss, BSER_NULL);
+  }
+};
+
+std::shared_ptr<BSERArray> decodeTemplate(std::istream &iss) {
+  expectType(iss, BSER_TEMPLATE);
+  auto keys = BSERArray(iss).arrayValue();
+  auto len = BSERInteger(iss).intValue();
+  std::shared_ptr<BSERArray> arr = std::make_shared<BSERArray>();
+  for (int64_t i = 0; i < len; i++) {
+    BSER::Object obj;
+    for (auto it = keys.begin(); it != keys.end(); it++) {
+      if (iss.peek() == 0x0c) {
+        iss.ignore(1);
+        continue;
+      }
+
+      auto val = BSER(iss);
+      obj.emplace(it->stringValue(), val);
+    }
+    arr->value.push_back(obj);
+  }
+  return arr;
+}
+
+BSER::BSER(std::istream &iss) {
+  BSERType type = decodeType(iss);
+  iss.unget();
+
+  switch (type) {
+    case BSER_ARRAY:
+      m_ptr = std::make_shared<BSERArray>(iss);
+      break;
+    case BSER_OBJECT:
+      m_ptr = std::make_shared<BSERObject>(iss);
+      break;
+    case BSER_STRING:
+      m_ptr = std::make_shared<BSERString>(iss);
+      break;
+    case BSER_INT8:
+    case BSER_INT16:
+    case BSER_INT32:
+    case BSER_INT64:
+      m_ptr = std::make_shared<BSERInteger>(iss);
+      break;
+    case BSER_REAL:
+      m_ptr = std::make_shared<BSERDouble>(iss);
+      break;
+    case BSER_BOOL_TRUE:
+      iss.ignore(1);
+      m_ptr = std::make_shared<BSERBoolean>(true);
+      break;
+    case BSER_BOOL_FALSE:
+      iss.ignore(1);
+      m_ptr = std::make_shared<BSERBoolean>(false);
+      break;
+    case BSER_NULL:
+      iss.ignore(1);
+      m_ptr = std::make_shared<BSERNull>();
+      break;
+    case BSER_TEMPLATE:
+      m_ptr = decodeTemplate(iss);
+      break;
+    default:
+      throw std::runtime_error("unknown BSER type");
+  }
+}
+
+BSER::BSER() : m_ptr(std::make_shared<BSERNull>()) {}
+BSER::BSER(BSER::Array value) : m_ptr(std::make_shared<BSERArray>(value)) {}
+BSER::BSER(BSER::Object value) : m_ptr(std::make_shared<BSERObject>(value)) {}
+BSER::BSER(const char *value) : m_ptr(std::make_shared<BSERString>(value)) {}
+BSER::BSER(std::string value) : m_ptr(std::make_shared<BSERString>(value)) {}
+BSER::BSER(int64_t value) : m_ptr(std::make_shared<BSERInteger>(value)) {}
+BSER::BSER(double value) : m_ptr(std::make_shared<BSERDouble>(value)) {}
+BSER::BSER(bool value) : m_ptr(std::make_shared<BSERBoolean>(value)) {}
+
+BSER::Array BSER::arrayValue() { return m_ptr->arrayValue(); }
+BSER::Object BSER::objectValue() { return m_ptr->objectValue(); }
+std::string BSER::stringValue() { return m_ptr->stringValue(); }
+int64_t BSER::intValue() { return m_ptr->intValue(); }
+double BSER::doubleValue() { return m_ptr->doubleValue(); }
+bool BSER::boolValue() { return m_ptr->boolValue(); }
+void BSER::encode(std::ostream &oss) {
+  m_ptr->encode(oss);
+}
+
+int64_t BSER::decodeLength(std::istream &iss) {
+  char pdu[2];
+  if (!iss.read(pdu, 2) || pdu[0] != 0 || pdu[1] != 1) {
+    throw std::runtime_error("Invalid BSER");
+  }
+
+  return BSERInteger(iss).intValue();
+}
+
+std::string BSER::encode() {
+  std::ostringstream oss(std::ios_base::binary);
+  encode(oss);
+
+  std::ostringstream res(std::ios_base::binary);
+  res.write("\x00\x01", 2);
+  
+  BSERInteger(oss.str().size()).encode(res);
+  res << oss.str();
+  return res.str();
+}

node_modules/@parcel/watcher/src/watchman/BSER.hh

@@ -0,0 +1,69 @@
+#ifndef BSER_H
+#define BSER_H
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+
+enum BSERType {
+  BSER_ARRAY = 0x00,
+  BSER_OBJECT = 0x01,
+  BSER_STRING = 0x02,
+  BSER_INT8 = 0x03,
+  BSER_INT16 = 0x04,
+  BSER_INT32 = 0x05,
+  BSER_INT64 = 0x06,
+  BSER_REAL = 0x07,
+  BSER_BOOL_TRUE = 0x08,
+  BSER_BOOL_FALSE = 0x09,
+  BSER_NULL = 0x0a,
+  BSER_TEMPLATE = 0x0b
+};
+
+class BSERValue;
+
+class BSER {
+public:
+  typedef std::vector<BSER> Array;
+  typedef std::unordered_map<std::string, BSER> Object;
+
+  BSER();
+  BSER(BSER::Array value);
+  BSER(BSER::Object value);
+  BSER(std::string value);
+  BSER(const char *value);
+  BSER(int64_t value);
+  BSER(double value);
+  BSER(bool value);
+  BSER(std::istream &iss);
+
+  BSER::Array arrayValue();
+  BSER::Object objectValue();
+  std::string stringValue();
+  int64_t intValue();
+  double doubleValue();
+  bool boolValue();
+  void encode(std::ostream &oss);
+
+  static int64_t decodeLength(std::istream &iss);
+  std::string encode();
+private:
+  std::shared_ptr<BSERValue> m_ptr;
+};
+
+class BSERValue {
+protected:
+  friend class BSER;
+  virtual BSER::Array arrayValue() { return BSER::Array(); }
+  virtual BSER::Object objectValue() { return BSER::Object(); }
+  virtual std::string stringValue() { return std::string(); }
+  virtual int64_t intValue() { return 0; }
+  virtual double doubleValue() { return 0; }
+  virtual bool boolValue() { return false; }
+  virtual void encode(std::ostream &oss) {}
+  virtual ~BSERValue() {}
+};
+
+#endif

node_modules/@parcel/watcher/src/watchman/IPC.hh

@@ -0,0 +1,175 @@
+#ifndef IPC_H
+#define IPC_H
+
+#include <string>
+#include <stdlib.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#endif
+
+class IPC {
+public:
+  IPC(std::string path) {
+    mStopped = false;
+    #ifdef _WIN32
+      while (true) {
+        mPipe = CreateFile(
+          path.data(), // pipe name
+          GENERIC_READ | GENERIC_WRITE, // read and write access
+          0, // no sharing
+          NULL, // default security attributes
+          OPEN_EXISTING, // opens existing pipe
+          FILE_FLAG_OVERLAPPED, // attributes
+          NULL // no template file
+        );
+
+        if (mPipe != INVALID_HANDLE_VALUE) {
+          break;
+        }
+
+        if (GetLastError() != ERROR_PIPE_BUSY) {
+          throw std::runtime_error("Could not open pipe");
+        }
+
+        // Wait for pipe to become available if it is busy
+        if (!WaitNamedPipe(path.data(), 30000)) {
+          throw std::runtime_error("Error waiting for pipe");
+        }
+      }
+
+      mReader = CreateEvent(NULL, true, false, NULL);
+      mWriter = CreateEvent(NULL, true, false, NULL);
+    #else
+      struct sockaddr_un addr;
+      memset(&addr, 0, sizeof(addr));
+      addr.sun_family = AF_UNIX;
+      strncpy(addr.sun_path, path.c_str(), sizeof(addr.sun_path) - 1);
+
+      mSock = socket(AF_UNIX, SOCK_STREAM, 0);
+      if (connect(mSock, (struct sockaddr *) &addr, sizeof(struct sockaddr_un))) {
+        throw std::runtime_error("Error connecting to socket");
+      }
+    #endif
+  }
+
+  ~IPC() {
+    mStopped = true;
+    #ifdef _WIN32
+      CancelIo(mPipe);
+      CloseHandle(mPipe);
+      CloseHandle(mReader);
+      CloseHandle(mWriter);
+    #else
+      shutdown(mSock, SHUT_RDWR);
+    #endif
+  }
+
+  void write(std::string buf) {
+    #ifdef _WIN32
+      OVERLAPPED overlapped;
+      overlapped.hEvent = mWriter;
+      bool success = WriteFile(
+        mPipe, // pipe handle
+        buf.data(), // message
+        buf.size(), // message length
+        NULL, // bytes written
+        &overlapped // overlapped
+      );
+
+      if (mStopped) {
+        return;
+      }
+
+      if (!success) {
+        if (GetLastError() != ERROR_IO_PENDING) {
+          throw std::runtime_error("Write error");
+        }
+      }
+
+      DWORD written;
+      success = GetOverlappedResult(mPipe, &overlapped, &written, true);
+      if (!success) {
+        throw std::runtime_error("GetOverlappedResult failed");
+      }
+
+      if (written != buf.size()) {
+        throw std::runtime_error("Wrong number of bytes written");
+      }
+    #else
+      int r = 0;
+      for (unsigned int i = 0; i != buf.size(); i += r) {
+        r = ::write(mSock, &buf[i], buf.size() - i);
+        if (r == -1) {
+          if (errno == EAGAIN) {
+            r = 0;
+          } else if (mStopped) {
+            return;
+          } else {
+            throw std::runtime_error("Write error");
+          }
+        }
+      }
+    #endif
+  }
+
+  int read(char *buf, size_t len) {
+    #ifdef _WIN32
+      OVERLAPPED overlapped;
+      overlapped.hEvent = mReader;
+      bool success = ReadFile(
+        mPipe, // pipe handle
+        buf, // buffer to receive reply
+        len, // size of buffer
+        NULL, // number of bytes read
+        &overlapped // overlapped
+      );
+
+      if (!success && !mStopped) {
+        if (GetLastError() != ERROR_IO_PENDING) {
+          throw std::runtime_error("Read error");
+        }
+      }
+
+      DWORD read = 0;
+      success = GetOverlappedResult(mPipe, &overlapped, &read, true);
+      if (!success && !mStopped) {
+        throw std::runtime_error("GetOverlappedResult failed");
+      }
+
+      return read;
+    #else
+      int r = ::read(mSock, buf, len);
+      if (r == 0 && !mStopped) {
+        throw std::runtime_error("Socket ended unexpectedly");
+      }
+
+      if (r < 0) {
+        if (mStopped) {
+          return 0;
+        }
+
+        throw std::runtime_error(strerror(errno));
+      }
+
+      return r;
+    #endif
+  }
+
+private:
+  bool mStopped;
+  #ifdef _WIN32
+    HANDLE mPipe;
+    HANDLE mReader;
+    HANDLE mWriter;
+  #else
+    int mSock;
+  #endif
+};
+
+#endif

node_modules/@parcel/watcher/src/watchman/WatchmanBackend.cc

@@ -0,0 +1,338 @@
+#include <string>
+#include <fstream>
+#include <stdlib.h>
+#include <algorithm>
+#include "../DirTree.hh"
+#include "../Event.hh"
+#include "./BSER.hh"
+#include "./WatchmanBackend.hh"
+
+#ifdef _WIN32
+#include "../windows/win_utils.hh"
+#define S_ISDIR(mode) ((mode & _S_IFDIR) == _S_IFDIR)
+#define popen _popen
+#define pclose _pclose
+#else
+#include <sys/stat.h>
+#define normalizePath(dir) dir
+#endif
+
+template<typename T>
+BSER readBSER(T &&do_read) {
+  std::stringstream oss;
+  char buffer[256];
+  int r;
+  int64_t len = -1;
+  do {
+    // Start by reading a minimal amount of data in order to decode the length.
+    // After that, attempt to read the remaining length, up to the buffer size.
+    r = do_read(buffer, len == -1 ? 20 : (len < 256 ? len : 256));
+    oss << std::string(buffer, r);
+
+    if (len == -1) {
+      uint64_t l = BSER::decodeLength(oss);
+      len = l + oss.tellg();
+    }
+
+    len -= r;
+  } while (len > 0);
+
+  return BSER(oss);
+}
+
+std::string getSockPath() {
+  auto var = getenv("WATCHMAN_SOCK");
+  if (var && *var) {
+    return std::string(var);
+  }
+
+  FILE *fp = popen("watchman --output-encoding=bser get-sockname", "r");
+  if (fp == NULL || errno == ECHILD) {
+    throw std::runtime_error("Failed to execute watchman");
+  }
+
+  BSER b = readBSER([fp] (char *buf, size_t len) {
+    return fread(buf, sizeof(char), len, fp);
+  });
+
+  pclose(fp);
+
+  auto objValue = b.objectValue();
+  auto foundSockname = objValue.find("sockname");
+  if (foundSockname == objValue.end()) {
+    throw std::runtime_error("sockname not found");
+  }
+  return foundSockname->second.stringValue();
+}
+
+std::unique_ptr<IPC> watchmanConnect() {
+  std::string path = getSockPath();
+  return std::unique_ptr<IPC>(new IPC(path));
+}
+
+BSER watchmanRead(IPC *ipc) {
+  return readBSER([ipc] (char *buf, size_t len) {
+    return ipc->read(buf, len);
+  });
+}
+
+BSER::Object WatchmanBackend::watchmanRequest(BSER b) {
+  std::string cmd = b.encode();
+  mIPC->write(cmd);
+  mRequestSignal.notify();
+
+  mResponseSignal.wait();
+  mResponseSignal.reset();
+
+  if (!mError.empty()) {
+    std::runtime_error err = std::runtime_error(mError);
+    mError = std::string();
+    throw err;
+  }
+
+  return mResponse;
+}
+
+void WatchmanBackend::watchmanWatch(std::string dir) {
+  std::vector<BSER> cmd;
+  cmd.push_back("watch");
+  cmd.push_back(normalizePath(dir));
+  watchmanRequest(cmd);
+}
+
+bool WatchmanBackend::checkAvailable() {
+  try {
+    watchmanConnect();
+    return true;
+  } catch (std::exception &err) {
+    return false;
+  }
+}
+
+void handleFiles(WatcherRef watcher, BSER::Object obj) {
+  auto found = obj.find("files");
+  if (found == obj.end()) {
+    throw WatcherError("Error reading changes from watchman", watcher);
+  }
+
+  auto files = found->second.arrayValue();
+  for (auto it = files.begin(); it != files.end(); it++) {
+    auto file = it->objectValue();
+    auto name = file.find("name")->second.stringValue();
+    #ifdef _WIN32
+      std::replace(name.begin(), name.end(), '/', '\\');
+    #endif
+    auto mode = file.find("mode")->second.intValue();
+    auto isNew = file.find("new")->second.boolValue();
+    auto exists = file.find("exists")->second.boolValue();
+    auto path = watcher->mDir + DIR_SEP + name;
+    if (watcher->isIgnored(path)) {
+      continue;
+    }
+
+    if (isNew && exists) {
+      watcher->mEvents.create(path);
+    } else if (exists && !S_ISDIR(mode)) {
+      watcher->mEvents.update(path);
+    } else if (!isNew && !exists) {
+      watcher->mEvents.remove(path);
+    }
+  }
+}
+
+void WatchmanBackend::handleSubscription(BSER::Object obj) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  auto subscription = obj.find("subscription")->second.stringValue();
+  auto it = mSubscriptions.find(subscription);
+  if (it == mSubscriptions.end()) {
+    return;
+  }
+
+  auto watcher = it->second;
+  try {
+    handleFiles(watcher, obj);
+    watcher->notify();
+  } catch (WatcherError &err) {
+    handleWatcherError(err);
+  }
+}
+
+void WatchmanBackend::start() {
+  mIPC = watchmanConnect();
+  notifyStarted();
+
+  while (true) {
+    // If there are no subscriptions we are reading, wait for a request.
+    if (mSubscriptions.size() == 0) {
+      mRequestSignal.wait();
+      mRequestSignal.reset();
+    }
+
+    // Break out of loop if we are stopped.
+    if (mStopped) {
+      break;
+    }
+
+    // Attempt to read from the socket.
+    // If there is an error and we are stopped, break.
+    BSER b;
+    try {
+      b = watchmanRead(&*mIPC);
+    } catch (std::exception &err) {
+      if (mStopped) {
+        break;
+      } else if (mResponseSignal.isWaiting()) {
+        mError = err.what();
+        mResponseSignal.notify();
+      } else {
+        // Throwing causes the backend to be destroyed, but we never reach the code below to notify the signal
+        mEndedSignal.notify();
+        throw;
+      }
+    }
+
+    auto obj = b.objectValue();
+    auto error = obj.find("error");
+    if (error != obj.end()) {
+      mError = error->second.stringValue();
+      mResponseSignal.notify();
+      continue;
+    }
+
+    // If this message is for a subscription, handle it, otherwise notify the request.
+    auto subscription = obj.find("subscription");
+    if (subscription != obj.end()) {
+      handleSubscription(obj);
+    } else {
+      mResponse = obj;
+      mResponseSignal.notify();
+    }
+  }
+
+  mEndedSignal.notify();
+}
+
+WatchmanBackend::~WatchmanBackend() {
+  // Mark the watcher as stopped, close the socket, and trigger the lock.
+  // This will cause the read loop to be broken and the thread to exit.
+  mStopped = true;
+  mIPC.reset();
+  mRequestSignal.notify();
+
+  // If not ended yet, wait.
+  mEndedSignal.wait();
+}
+
+std::string WatchmanBackend::clock(WatcherRef watcher) {
+  BSER::Array cmd;
+  cmd.push_back("clock");
+  cmd.push_back(normalizePath(watcher->mDir));
+
+  BSER::Object obj = watchmanRequest(cmd);
+  auto found = obj.find("clock");
+  if (found == obj.end()) {
+    throw WatcherError("Error reading clock from watchman", watcher);
+  }
+
+  return found->second.stringValue();
+}
+
+void WatchmanBackend::writeSnapshot(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  watchmanWatch(watcher->mDir);
+
+  std::ofstream ofs(*snapshotPath);
+  ofs << clock(watcher);
+}
+
+void WatchmanBackend::getEventsSince(WatcherRef watcher, std::string *snapshotPath) {
+  std::unique_lock<std::mutex> lock(mMutex);
+  std::ifstream ifs(*snapshotPath);
+  if (ifs.fail()) {
+    return;
+  }
+
+  watchmanWatch(watcher->mDir);
+
+  std::string clock;
+  ifs >> clock;
+
+  BSER::Array cmd;
+  cmd.push_back("since");
+  cmd.push_back(normalizePath(watcher->mDir));
+  cmd.push_back(clock);
+
+  BSER::Object obj = watchmanRequest(cmd);
+  handleFiles(watcher, obj);
+}
+
+std::string getId(WatcherRef watcher) {
+  std::ostringstream id;
+  id << "parcel-";
+  id << static_cast<void*>(watcher.get());
+  return id.str();
+}
+
+// This function is called by Backend::watch which takes a lock on mMutex
+void WatchmanBackend::subscribe(WatcherRef watcher) {
+  watchmanWatch(watcher->mDir);
+
+  std::string id = getId(watcher);
+  BSER::Array cmd;
+  cmd.push_back("subscribe");
+  cmd.push_back(normalizePath(watcher->mDir));
+  cmd.push_back(id);
+
+  BSER::Array fields;
+  fields.push_back("name");
+  fields.push_back("mode");
+  fields.push_back("exists");
+  fields.push_back("new");
+
+  BSER::Object opts;
+  opts.emplace("fields", fields);
+  opts.emplace("since", clock(watcher));
+
+  if (watcher->mIgnorePaths.size() > 0) {
+    BSER::Array ignore;
+    BSER::Array anyOf;
+    anyOf.push_back("anyof");
+
+    for (auto it = watcher->mIgnorePaths.begin(); it != watcher->mIgnorePaths.end(); it++) {
+      std::string pathStart = watcher->mDir + DIR_SEP;
+      if (it->rfind(pathStart, 0) == 0) {
+        auto relative = it->substr(pathStart.size());
+        BSER::Array dirname;
+        dirname.push_back("dirname");
+        dirname.push_back(relative);
+        anyOf.push_back(dirname);
+      }
+    }
+
+    ignore.push_back("not");
+    ignore.push_back(anyOf);
+
+    opts.emplace("expression", ignore);
+  }
+
+  cmd.push_back(opts);
+  watchmanRequest(cmd);
+
+  mSubscriptions.emplace(id, watcher);
+  mRequestSignal.notify();
+}
+
+// This function is called by Backend::unwatch which takes a lock on mMutex
+void WatchmanBackend::unsubscribe(WatcherRef watcher) {
+  std::string id = getId(watcher);
+  auto erased = mSubscriptions.erase(id);
+
+  if (erased) {
+    BSER::Array cmd;
+    cmd.push_back("unsubscribe");
+    cmd.push_back(normalizePath(watcher->mDir));
+    cmd.push_back(id);
+
+    watchmanRequest(cmd);
+  }
+}

node_modules/@parcel/watcher/src/watchman/WatchmanBackend.hh

@@ -0,0 +1,35 @@
+#ifndef WATCHMAN_H
+#define WATCHMAN_H
+
+#include "../Backend.hh"
+#include "./BSER.hh"
+#include "../Signal.hh"
+#include "./IPC.hh"
+
+class WatchmanBackend : public Backend {
+public:
+  static bool checkAvailable();
+  void start() override;
+  WatchmanBackend() : mStopped(false) {};
+  ~WatchmanBackend();
+  void writeSnapshot(WatcherRef watcher, std::string *snapshotPath) override;
+  void getEventsSince(WatcherRef watcher, std::string *snapshotPath) override;
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+private:
+  std::unique_ptr<IPC> mIPC;
+  Signal mRequestSignal;
+  Signal mResponseSignal;
+  BSER::Object mResponse;
+  std::string mError;
+  std::unordered_map<std::string, WatcherRef> mSubscriptions;
+  bool mStopped;
+  Signal mEndedSignal;
+
+  std::string clock(WatcherRef watcher);
+  void watchmanWatch(std::string dir);
+  BSER::Object watchmanRequest(BSER cmd);
+  void handleSubscription(BSER::Object obj);
+};
+
+#endif

node_modules/@parcel/watcher/src/windows/WindowsBackend.cc

@@ -0,0 +1,282 @@
+#include <string>
+#include <stack>
+#include "../DirTree.hh"
+#include "../shared/BruteForceBackend.hh"
+#include "./WindowsBackend.hh"
+#include "./win_utils.hh"
+
+#define DEFAULT_BUF_SIZE 1024 * 1024
+#define NETWORK_BUF_SIZE 64 * 1024
+#define CONVERT_TIME(ft) ULARGE_INTEGER{ft.dwLowDateTime, ft.dwHighDateTime}.QuadPart
+
+void BruteForceBackend::readTree(WatcherRef watcher, std::shared_ptr<DirTree> tree) {
+  std::stack<std::string> directories;
+
+  directories.push(watcher->mDir);
+
+  while (!directories.empty()) {
+    HANDLE hFind = INVALID_HANDLE_VALUE;
+
+    std::string path = directories.top();
+    std::string spec = path + "\\*";
+    directories.pop();
+
+    WIN32_FIND_DATA ffd;
+    hFind = FindFirstFile(spec.c_str(), &ffd);
+
+    if (hFind == INVALID_HANDLE_VALUE)  {
+      if (path == watcher->mDir) {
+        FindClose(hFind);
+        throw WatcherError("Error opening directory", watcher);
+      }
+
+      tree->remove(path);
+      continue;
+    }
+
+    do {
+      if (strcmp(ffd.cFileName, ".") != 0 && strcmp(ffd.cFileName, "..") != 0) {
+        std::string fullPath = path + "\\" + ffd.cFileName;
+        if (watcher->isIgnored(fullPath)) {
+          continue;
+        }
+
+        tree->add(fullPath, CONVERT_TIME(ffd.ftLastWriteTime), ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+        if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+          directories.push(fullPath);
+        }
+      }
+    } while (FindNextFile(hFind, &ffd) != 0);
+
+    FindClose(hFind);
+  }
+}
+
+void WindowsBackend::start() {
+  mRunning = true;
+  notifyStarted();
+
+  while (mRunning) {
+    SleepEx(INFINITE, true);
+  }
+}
+
+WindowsBackend::~WindowsBackend() {
+  // Mark as stopped, and queue a noop function in the thread to break the loop
+  mRunning = false;
+  QueueUserAPC([](__in ULONG_PTR) {}, mThread.native_handle(), (ULONG_PTR)this);
+}
+
+class Subscription: public WatcherState {
+public:
+  Subscription(WindowsBackend *backend, WatcherRef watcher, std::shared_ptr<DirTree> tree) {
+    mRunning = true;
+    mBackend = backend;
+    mWatcher = watcher;
+    mTree = tree;
+    ZeroMemory(&mOverlapped, sizeof(OVERLAPPED));
+    mOverlapped.hEvent = this;
+    mReadBuffer.resize(DEFAULT_BUF_SIZE);
+    mWriteBuffer.resize(DEFAULT_BUF_SIZE);
+
+    mDirectoryHandle = CreateFileW(
+      utf8ToUtf16(watcher->mDir).data(),
+      FILE_LIST_DIRECTORY,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+      NULL,
+      OPEN_EXISTING,
+      FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
+      NULL
+    );
+
+    if (mDirectoryHandle == INVALID_HANDLE_VALUE) {
+      throw WatcherError("Invalid handle", mWatcher);
+    }
+
+    // Ensure that the path is a directory
+    BY_HANDLE_FILE_INFORMATION info;
+    bool success = GetFileInformationByHandle(
+      mDirectoryHandle,
+      &info
+    );
+
+    if (!success) {
+      throw WatcherError("Could not get file information", mWatcher);
+    }
+
+    if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+      throw WatcherError("Not a directory", mWatcher);
+    }
+  }
+
+  virtual ~Subscription() {
+    stop();
+  }
+
+  void run() {
+    try {
+      poll();
+    } catch (WatcherError &err) {
+      mBackend->handleWatcherError(err);
+    }
+  }
+
+  void stop() {
+    if (mRunning) {
+      mRunning = false;
+      CancelIo(mDirectoryHandle);
+      CloseHandle(mDirectoryHandle);
+    }
+  }
+
+  void poll() {
+    if (!mRunning) {
+      return;
+    }
+
+    // Asynchronously wait for changes.
+    int success = ReadDirectoryChangesW(
+      mDirectoryHandle,
+      mWriteBuffer.data(),
+      static_cast<DWORD>(mWriteBuffer.size()),
+      TRUE, // recursive
+      FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES
+        | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE,
+      NULL,
+      &mOverlapped,
+      [](DWORD errorCode, DWORD numBytes, LPOVERLAPPED overlapped) {
+        auto subscription = reinterpret_cast<Subscription *>(overlapped->hEvent);
+        try {
+          subscription->processEvents(errorCode);
+        } catch (WatcherError &err) {
+          subscription->mBackend->handleWatcherError(err);
+        }
+      }
+    );
+
+    if (!success) {
+      throw WatcherError("Failed to read changes", mWatcher);
+    }
+  }
+
+  void processEvents(DWORD errorCode) {
+    if (!mRunning) {
+      return;
+    }
+
+    switch (errorCode) {
+      case ERROR_OPERATION_ABORTED:
+        return;
+      case ERROR_INVALID_PARAMETER:
+        // resize buffers to network size (64kb), and try again
+        mReadBuffer.resize(NETWORK_BUF_SIZE);
+        mWriteBuffer.resize(NETWORK_BUF_SIZE);
+        poll();
+        return;
+      case ERROR_NOTIFY_ENUM_DIR:
+        throw WatcherError("Buffer overflow. Some events may have been lost.", mWatcher);
+      case ERROR_ACCESS_DENIED: {
+        // This can happen if the watched directory is deleted. Check if that is the case,
+        // and if so emit a delete event. Otherwise, fall through to default error case.
+        DWORD attrs = GetFileAttributesW(utf8ToUtf16(mWatcher->mDir).data());
+        bool isDir = attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY);
+        if (!isDir) {
+          mWatcher->mEvents.remove(mWatcher->mDir);
+          mTree->remove(mWatcher->mDir);
+          mWatcher->notify();
+          stop();
+          return;
+        }
+      }
+      default:
+        if (errorCode != ERROR_SUCCESS) {
+          throw WatcherError("Unknown error", mWatcher);
+        }
+    }
+
+    // Swap read and write buffers, and poll again
+    std::swap(mWriteBuffer, mReadBuffer);
+    poll();
+
+    // Read change events
+    BYTE *base = mReadBuffer.data();
+    while (true) {
+      PFILE_NOTIFY_INFORMATION info = (PFILE_NOTIFY_INFORMATION)base;
+      processEvent(info);
+
+      if (info->NextEntryOffset == 0) {
+        break;
+      }
+
+      base += info->NextEntryOffset;
+    }
+
+    mWatcher->notify();
+  }
+
+  void processEvent(PFILE_NOTIFY_INFORMATION info) {
+    std::string path = mWatcher->mDir + "\\" + utf16ToUtf8(info->FileName, info->FileNameLength / sizeof(WCHAR));
+    if (mWatcher->isIgnored(path)) {
+      return;
+    }
+
+    switch (info->Action) {
+      case FILE_ACTION_ADDED:
+      case FILE_ACTION_RENAMED_NEW_NAME: {
+        WIN32_FILE_ATTRIBUTE_DATA data;
+        if (GetFileAttributesExW(utf8ToUtf16(path).data(), GetFileExInfoStandard, &data)) {
+          mWatcher->mEvents.create(path);
+          mTree->add(path, CONVERT_TIME(data.ftLastWriteTime), data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+        }
+        break;
+      }
+      case FILE_ACTION_MODIFIED: {
+        WIN32_FILE_ATTRIBUTE_DATA data;
+        if (GetFileAttributesExW(utf8ToUtf16(path).data(), GetFileExInfoStandard, &data)) {
+          mTree->update(path, CONVERT_TIME(data.ftLastWriteTime));
+          if (!(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+            mWatcher->mEvents.update(path);
+          }
+        }
+        break;
+      }
+      case FILE_ACTION_REMOVED:
+      case FILE_ACTION_RENAMED_OLD_NAME:
+        mWatcher->mEvents.remove(path);
+        mTree->remove(path);
+        break;
+    }
+  }
+
+private:
+  WindowsBackend *mBackend;
+  std::shared_ptr<Watcher> mWatcher;
+  std::shared_ptr<DirTree> mTree;
+  bool mRunning;
+  HANDLE mDirectoryHandle;
+  std::vector<BYTE> mReadBuffer;
+  std::vector<BYTE> mWriteBuffer;
+  OVERLAPPED mOverlapped;
+};
+
+// This function is called by Backend::watch which takes a lock on mMutex
+void WindowsBackend::subscribe(WatcherRef watcher) {
+  // Create a subscription for this watcher
+  auto sub = std::make_shared<Subscription>(this, watcher, getTree(watcher, false));
+  watcher->state = sub;
+
+  // Queue polling for this subscription in the correct thread.
+  bool success = QueueUserAPC([](__in ULONG_PTR ptr) {
+    Subscription *sub = (Subscription *)ptr;
+    sub->run();
+  }, mThread.native_handle(), (ULONG_PTR)sub.get());
+
+  if (!success) {
+    throw std::runtime_error("Unable to queue APC");
+  }
+}
+
+// This function is called by Backend::unwatch which takes a lock on mMutex
+void WindowsBackend::unsubscribe(WatcherRef watcher) {
+  watcher->state = nullptr;
+}

node_modules/@parcel/watcher/src/windows/WindowsBackend.hh

@@ -0,0 +1,18 @@
+#ifndef WINDOWS_H
+#define WINDOWS_H
+
+#include <winsock2.h>
+#include <windows.h>
+#include "../shared/BruteForceBackend.hh"
+
+class WindowsBackend : public BruteForceBackend {
+public:
+  void start() override;
+  ~WindowsBackend();
+  void subscribe(WatcherRef watcher) override;
+  void unsubscribe(WatcherRef watcher) override;
+private:
+  bool mRunning;
+};
+
+#endif

node_modules/@parcel/watcher/src/windows/win_utils.cc

@@ -0,0 +1,44 @@
+#include "./win_utils.hh"
+
+std::wstring utf8ToUtf16(std::string input) {
+  unsigned int len = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0);
+  WCHAR *output = new WCHAR[len];
+  MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, output, len);
+  std::wstring res(output);
+  delete output;
+  return res;
+}
+
+std::string utf16ToUtf8(const WCHAR *input, size_t length) {
+  unsigned int len = WideCharToMultiByte(CP_UTF8, 0, input, length, NULL, 0, NULL, NULL);
+  char *output = new char[len + 1];
+  WideCharToMultiByte(CP_UTF8, 0, input, length, output, len, NULL, NULL);
+  output[len] = '\0';
+  std::string res(output);
+  delete output;
+  return res;
+}
+
+std::string normalizePath(std::string path) {
+  // Prevent truncation to MAX_PATH characters by adding the \\?\ prefix
+  std::wstring p = utf8ToUtf16("\\\\?\\" + path);
+
+  // Get the required length for the output
+  unsigned int len = GetLongPathNameW(p.data(), NULL, 0);
+  if (!len) {
+    return path;
+  }
+
+  // Allocate output array and get long path
+  WCHAR *output = new WCHAR[len];
+  len = GetLongPathNameW(p.data(), output, len);
+  if (!len) {
+    delete output;
+    return path;
+  }
+
+  // Convert back to utf8
+  std::string res = utf16ToUtf8(output + 4, len - 4);
+  delete output;
+  return res;
+}

node_modules/@parcel/watcher/src/windows/win_utils.hh

@@ -0,0 +1,11 @@
+#ifndef WIN_UTILS_H
+#define WIN_UTILS_H
+
+#include <string>
+#include <windows.h>
+
+std::wstring utf8ToUtf16(std::string input);
+std::string utf16ToUtf8(const WCHAR *input, size_t length);
+std::string normalizePath(std::string path);
+
+#endif

node_modules/@parcel/watcher/wrapper.js

@@ -0,0 +1,77 @@
+const path = require('path');
+const micromatch = require('micromatch');
+const isGlob = require('is-glob');
+
+function normalizeOptions(dir, opts = {}) {
+  const { ignore, ...rest } = opts;
+
+  if (Array.isArray(ignore)) {
+    opts = { ...rest };
+
+    for (const value of ignore) {
+      if (isGlob(value)) {
+        if (!opts.ignoreGlobs) {
+          opts.ignoreGlobs = [];
+        }
+
+        const regex = micromatch.makeRe(value, {
+          // We set `dot: true` to workaround an issue with the
+          // regular expression on Linux where the resulting
+          // negative lookahead `(?!(\\/|^)` was never matching
+          // in some cases. See also https://bit.ly/3UZlQDm
+          dot: true,
+          // C++ does not support lookbehind regex patterns, they
+          // were only added later to JavaScript engines
+          // (https://bit.ly/3V7S6UL)
+          lookbehinds: false
+        });
+        opts.ignoreGlobs.push(regex.source);
+      } else {
+        if (!opts.ignorePaths) {
+          opts.ignorePaths = [];
+        }
+
+        opts.ignorePaths.push(path.resolve(dir, value));
+      }
+    }
+  }
+
+  return opts;
+}
+
+exports.createWrapper = (binding) => {
+  return {
+    writeSnapshot(dir, snapshot, opts) {
+      return binding.writeSnapshot(
+        path.resolve(dir),
+        path.resolve(snapshot),
+        normalizeOptions(dir, opts),
+      );
+    },
+    getEventsSince(dir, snapshot, opts) {
+      return binding.getEventsSince(
+        path.resolve(dir),
+        path.resolve(snapshot),
+        normalizeOptions(dir, opts),
+      );
+    },
+    async subscribe(dir, fn, opts) {
+      dir = path.resolve(dir);
+      opts = normalizeOptions(dir, opts);
+      await binding.subscribe(dir, fn, opts);
+
+      return {
+        unsubscribe() {
+          return binding.unsubscribe(dir, fn, opts);
+        },
+      };
+    },
+    unsubscribe(dir, fn, opts) {
+      return binding.unsubscribe(
+        path.resolve(dir),
+        fn,
+        normalizeOptions(dir, opts),
+      );
+    }
+  };
+};

node_modules/abort-controller/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Toru Nagashima
+
+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.

node_modules/abort-controller/README.md

@@ -0,0 +1,98 @@
+# abort-controller
+
+[![npm version](https://img.shields.io/npm/v/abort-controller.svg)](https://www.npmjs.com/package/abort-controller)
+[![Downloads/month](https://img.shields.io/npm/dm/abort-controller.svg)](http://www.npmtrends.com/abort-controller)
+[![Build Status](https://travis-ci.org/mysticatea/abort-controller.svg?branch=master)](https://travis-ci.org/mysticatea/abort-controller)
+[![Coverage Status](https://codecov.io/gh/mysticatea/abort-controller/branch/master/graph/badge.svg)](https://codecov.io/gh/mysticatea/abort-controller)
+[![Dependency Status](https://david-dm.org/mysticatea/abort-controller.svg)](https://david-dm.org/mysticatea/abort-controller)
+
+An implementation of [WHATWG AbortController interface](https://dom.spec.whatwg.org/#interface-abortcontroller).
+
+```js
+import AbortController from "abort-controller"
+
+const controller = new AbortController()
+const signal = controller.signal
+
+signal.addEventListener("abort", () => {
+    console.log("aborted!")
+})
+
+controller.abort()
+```
+
+> https://jsfiddle.net/1r2994qp/1/
+
+## 💿 Installation
+
+Use [npm](https://www.npmjs.com/) to install then use a bundler.
+
+```
+npm install abort-controller
+```
+
+Or download from [`dist` directory](./dist).
+
+- [dist/abort-controller.mjs](dist/abort-controller.mjs) ... ES modules version.
+- [dist/abort-controller.js](dist/abort-controller.js) ... Common JS version.
+- [dist/abort-controller.umd.js](dist/abort-controller.umd.js) ... UMD (Universal Module Definition) version. This is transpiled by [Babel](https://babeljs.io/) for IE 11.
+
+## 📖 Usage
+
+### Basic
+
+```js
+import AbortController from "abort-controller"
+// or
+const AbortController = require("abort-controller")
+
+// or UMD version defines a global variable:
+const AbortController = window.AbortControllerShim
+```
+
+If your bundler recognizes `browser` field of `package.json`, the imported `AbortController` is the native one and it doesn't contain shim (even if the native implementation was nothing).
+If you wanted to polyfill `AbortController` for IE, use `abort-controller/polyfill`.
+
+### Polyfilling
+
+Importing `abort-controller/polyfill` assigns the `AbortController` shim to the `AbortController` global variable if the native implementation was nothing.
+
+```js
+import "abort-controller/polyfill"
+// or
+require("abort-controller/polyfill")
+```
+
+### API
+
+#### AbortController
+
+> https://dom.spec.whatwg.org/#interface-abortcontroller
+
+##### controller.signal
+
+The [AbortSignal](https://dom.spec.whatwg.org/#interface-AbortSignal) object which is associated to this controller.
+
+##### controller.abort()
+
+Notify `abort` event to listeners that the `signal` has.
+
+## 📰 Changelog
+
+- See [GitHub releases](https://github.com/mysticatea/abort-controller/releases).
+
+## 🍻 Contributing
+
+Contributing is welcome ❤️
+
+Please use GitHub issues/PRs.
+
+### Development tools
+
+- `npm install` installs dependencies for development.
+- `npm test` runs tests and measures code coverage.
+- `npm run clean` removes temporary files of tests.
+- `npm run coverage` opens code coverage of the previous test with your default browser.
+- `npm run lint` runs ESLint.
+- `npm run build` generates `dist` codes.
+- `npm run watch` runs tests on each file change.

node_modules/abort-controller/browser.js

@@ -0,0 +1,13 @@
+/*globals self, window */
+"use strict"
+
+/*eslint-disable @mysticatea/prettier */
+const { AbortController, AbortSignal } =
+    typeof self !== "undefined" ? self :
+    typeof window !== "undefined" ? window :
+    /* otherwise */ undefined
+/*eslint-enable @mysticatea/prettier */
+
+module.exports = AbortController
+module.exports.AbortSignal = AbortSignal
+module.exports.default = AbortController

node_modules/abort-controller/browser.mjs

@@ -0,0 +1,11 @@
+/*globals self, window */
+
+/*eslint-disable @mysticatea/prettier */
+const { AbortController, AbortSignal } =
+    typeof self !== "undefined" ? self :
+    typeof window !== "undefined" ? window :
+    /* otherwise */ undefined
+/*eslint-enable @mysticatea/prettier */
+
+export default AbortController
+export { AbortController, AbortSignal }

node_modules/abort-controller/dist/abort-controller.d.ts

@@ -0,0 +1,43 @@
+import { EventTarget } from "event-target-shim"
+
+type Events = {
+    abort: any
+}
+type EventAttributes = {
+    onabort: any
+}
+/**
+ * The signal class.
+ * @see https://dom.spec.whatwg.org/#abortsignal
+ */
+declare class AbortSignal extends EventTarget<Events, EventAttributes> {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    constructor()
+    /**
+     * Returns `true` if this `AbortSignal`"s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    readonly aborted: boolean
+}
+/**
+ * The AbortController.
+ * @see https://dom.spec.whatwg.org/#abortcontroller
+ */
+declare class AbortController {
+    /**
+     * Initialize this controller.
+     */
+    constructor()
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    readonly signal: AbortSignal
+    /**
+     * Abort and signal to any observers that the associated activity is to be aborted.
+     */
+    abort(): void
+}
+
+export default AbortController
+export { AbortController, AbortSignal }

node_modules/abort-controller/dist/abort-controller.js

@@ -0,0 +1,127 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var eventTargetShim = require('event-target-shim');
+
+/**
+ * The signal class.
+ * @see https://dom.spec.whatwg.org/#abortsignal
+ */
+class AbortSignal extends eventTargetShim.EventTarget {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    constructor() {
+        super();
+        throw new TypeError("AbortSignal cannot be constructed directly");
+    }
+    /**
+     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    get aborted() {
+        const aborted = abortedFlags.get(this);
+        if (typeof aborted !== "boolean") {
+            throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+        }
+        return aborted;
+    }
+}
+eventTargetShim.defineEventAttribute(AbortSignal.prototype, "abort");
+/**
+ * Create an AbortSignal object.
+ */
+function createAbortSignal() {
+    const signal = Object.create(AbortSignal.prototype);
+    eventTargetShim.EventTarget.call(signal);
+    abortedFlags.set(signal, false);
+    return signal;
+}
+/**
+ * Abort a given signal.
+ */
+function abortSignal(signal) {
+    if (abortedFlags.get(signal) !== false) {
+        return;
+    }
+    abortedFlags.set(signal, true);
+    signal.dispatchEvent({ type: "abort" });
+}
+/**
+ * Aborted flag for each instances.
+ */
+const abortedFlags = new WeakMap();
+// Properties should be enumerable.
+Object.defineProperties(AbortSignal.prototype, {
+    aborted: { enumerable: true },
+});
+// `toString()` should return `"[object AbortSignal]"`
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortSignal",
+    });
+}
+
+/**
+ * The AbortController.
+ * @see https://dom.spec.whatwg.org/#abortcontroller
+ */
+class AbortController {
+    /**
+     * Initialize this controller.
+     */
+    constructor() {
+        signals.set(this, createAbortSignal());
+    }
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    get signal() {
+        return getSignal(this);
+    }
+    /**
+     * Abort and signal to any observers that the associated activity is to be aborted.
+     */
+    abort() {
+        abortSignal(getSignal(this));
+    }
+}
+/**
+ * Associated signals.
+ */
+const signals = new WeakMap();
+/**
+ * Get the associated signal of a given controller.
+ */
+function getSignal(controller) {
+    const signal = signals.get(controller);
+    if (signal == null) {
+        throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+    }
+    return signal;
+}
+// Properties should be enumerable.
+Object.defineProperties(AbortController.prototype, {
+    signal: { enumerable: true },
+    abort: { enumerable: true },
+});
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortController",
+    });
+}
+
+exports.AbortController = AbortController;
+exports.AbortSignal = AbortSignal;
+exports.default = AbortController;
+
+module.exports = AbortController
+module.exports.AbortController = module.exports["default"] = AbortController
+module.exports.AbortSignal = AbortSignal
+//# sourceMappingURL=abort-controller.js.map

node_modules/abort-controller/dist/abort-controller.mjs

@@ -0,0 +1,118 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+import { EventTarget, defineEventAttribute } from 'event-target-shim';
+
+/**
+ * The signal class.
+ * @see https://dom.spec.whatwg.org/#abortsignal
+ */
+class AbortSignal extends EventTarget {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    constructor() {
+        super();
+        throw new TypeError("AbortSignal cannot be constructed directly");
+    }
+    /**
+     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    get aborted() {
+        const aborted = abortedFlags.get(this);
+        if (typeof aborted !== "boolean") {
+            throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+        }
+        return aborted;
+    }
+}
+defineEventAttribute(AbortSignal.prototype, "abort");
+/**
+ * Create an AbortSignal object.
+ */
+function createAbortSignal() {
+    const signal = Object.create(AbortSignal.prototype);
+    EventTarget.call(signal);
+    abortedFlags.set(signal, false);
+    return signal;
+}
+/**
+ * Abort a given signal.
+ */
+function abortSignal(signal) {
+    if (abortedFlags.get(signal) !== false) {
+        return;
+    }
+    abortedFlags.set(signal, true);
+    signal.dispatchEvent({ type: "abort" });
+}
+/**
+ * Aborted flag for each instances.
+ */
+const abortedFlags = new WeakMap();
+// Properties should be enumerable.
+Object.defineProperties(AbortSignal.prototype, {
+    aborted: { enumerable: true },
+});
+// `toString()` should return `"[object AbortSignal]"`
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortSignal",
+    });
+}
+
+/**
+ * The AbortController.
+ * @see https://dom.spec.whatwg.org/#abortcontroller
+ */
+class AbortController {
+    /**
+     * Initialize this controller.
+     */
+    constructor() {
+        signals.set(this, createAbortSignal());
+    }
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    get signal() {
+        return getSignal(this);
+    }
+    /**
+     * Abort and signal to any observers that the associated activity is to be aborted.
+     */
+    abort() {
+        abortSignal(getSignal(this));
+    }
+}
+/**
+ * Associated signals.
+ */
+const signals = new WeakMap();
+/**
+ * Get the associated signal of a given controller.
+ */
+function getSignal(controller) {
+    const signal = signals.get(controller);
+    if (signal == null) {
+        throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+    }
+    return signal;
+}
+// Properties should be enumerable.
+Object.defineProperties(AbortController.prototype, {
+    signal: { enumerable: true },
+    abort: { enumerable: true },
+});
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortController",
+    });
+}
+
+export default AbortController;
+export { AbortController, AbortSignal };
+//# sourceMappingURL=abort-controller.mjs.map