first commit

2026-04-13 22:01:33 +02:00 · 2026-04-13 22:01:33 +02:00 · 7e98019c2c
commit 7e98019c2c
7518 changed files with 1397478 additions and 0 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/.env.example
+++ b/.env.example
@ -0,0 +1 @@
+ANTHROPIC_API_KEY=your-api-key-here
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -0,0 +1,67 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+JARVIS is an Electron-based desktop voice assistant with a particle animation UI. It listens for the wake word "Jarvis", captures a voice command, sends it to the Claude CLI for processing (with Bash tool access), and speaks the response aloud using macOS TTS. No build step, no TypeScript, no bundler — vanilla JavaScript + Electron.
+
+## Running the App
+
+```bash
+npm install    # first time only
+npm start      # launches Electron
+```
+
+The app requires:
+- macOS (uses the `say` command for TTS)
+- Claude CLI installed and accessible in PATH (`claude` command)
+- `whisper-cpp` installed (`brew install whisper-cpp`) — provides `whisper-server`
+- A GGML model at `~/whisper-models/ggml-base.bin` (override with `JARVIS_WHISPER_MODEL` env var). Download: `curl -L -o ~/whisper-models/ggml-base.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin`
+
+## Architecture
+
+The app has three layers:
+
+**`main.js` — Electron main process**
+- Starts a local HTTP server on port 52736 (serves the renderer — required for `getUserMedia` to work in a secure context, not `file://`)
+- Spawns `whisper-server` on port 52737 at startup (loads the GGML model once; killed on `before-quit`)
+- Handles IPC: `askClaude`, `speak`, `stopSpeak`, `showContextMenu`, `whisperUrl`
+- Calls the Claude CLI via `execFile` with `--model opus --allowed-tools Bash --dangerously-skip-permissions`, `cwd` set to `$HOME`
+- Maintains conversation history (max 20 messages) in memory
+- Detects French vs. English in responses to pick the `say` voice (Thomas vs. Alex)
+
+**`preload.js` — context bridge**
+- Exposes `window.jarvis.{askClaude, speak, stopSpeak, showContextMenu, whisperUrl}` with context isolation.
+
+**`renderer.js` — UI + voice pipeline**
+- `JarvisVisualizer`: Canvas-based particle animation. States: idle (cyan), listening (green), thinking (amber), speaking (light blue).
+- `AudioPipeline`: `getUserMedia` → `AudioContext({sampleRate: 16000})` → `ScriptProcessorNode` delivers Float32 frames.
+- `encodeWAV` / `transcribe`: encodes Float32 PCM to 16-bit WAV Blob and POSTs to `http://127.0.0.1:52737/inference` (multipart `file`, `response_format=text`).
+- `JarvisController`: state machine (`idle`/`listening`/`thinking`/`speaking`) driving the full pipeline.
+
+**Note**: We do NOT use `webkitSpeechRecognition` — it's broken in Electron (missing Google API key → `network` error). All STT goes through local whisper-server.
+
+## Voice Pipeline Flow
+
+1. **Idle**: every 1.2s, take the last 2.2s from a rolling 3s ring buffer; if RMS above floor, POST to whisper-server. If transcription matches `/\bjarvis\b/i` → enter listening with the trailing text as inline command.
+2. **Listening**: accumulate Float32 frames into `cmdChunks`. Per-frame RMS drives a VAD: after speech onset, 1.5s of silence (or 12s max) → finalize.
+3. **Finalize**: concat chunks, encode WAV, transcribe once, combine with inline → Claude CLI → `say`.
+4. Audio capture is gated off during `thinking`/`speaking` so JARVIS never hears its own voice. Ring buffer is cleared on entry to listening and on return to idle.
+
+## Key Constants (in `main.js`)
+
+- Claude model alias: `opus`
+- CLI timeout: 120s, output buffer: 2MB
+- Conversation history cap: 20 items
+- Local HTTP server port: 52736
+- Whisper server port: 52737
+- Whisper model path: `$JARVIS_WHISPER_MODEL` or `~/whisper-models/ggml-base.bin`
+
+## Making Changes
+
+- **System prompt / personality**: Edit `buildPrompt()` in `main.js`
+- **Claude model or CLI flags**: Edit the `execFile` call in `askClaude()` in `main.js`
+- **Wake word or silence timeout**: Edit `_startWakeLoop()` / `_listenContinuous()` in `renderer.js`
+- **Visual states or animation**: Edit `JarvisVisualizer` in `renderer.js`
+- Restart `npm start` after any change to see the effect (no hot reload)
--- a/build/icon.png
+++ b/build/icon.png
--- a/com.david.jarvis.plist
+++ b/com.david.jarvis.plist
@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.david.jarvis</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/zsh</string>
+    <string>-lc</string>
+    <string>cd /Users/david/Documents/Dev/jarvis && /opt/homebrew/bin/npm start</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <false/>
+
+  <key>StandardOutPath</key>
+  <string>/Users/david/Documents/Dev/jarvis/jarvis.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>/Users/david/Documents/Dev/jarvis/jarvis.err.log</string>
+</dict>
+</plist>
--- a/index.html
+++ b/index.html
@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <title>J.A.R.V.I.S.</title>
+  <link rel="stylesheet" href="style.css">
+</head>
+<body>
+  <canvas id="canvas"></canvas>
+  <script src="renderer.js"></script>
+</body>
+</html>
--- a/main.js
+++ b/main.js
@ -0,0 +1,404 @@
+'use strict';
+
+const { app, BrowserWindow, ipcMain, Menu, globalShortcut, systemPreferences, nativeImage } = require('electron');
+const path   = require('path');
+const os     = require('os');
+const fs     = require('fs');
+const http   = require('http');
+const { spawn, execSync, execFile } = require('child_process');
+
+// ============================================================
+// CONFIG
+// ============================================================
+
+const PORT          = 52736;
+const WHISPER_PORT  = 52737;
+function pickWhisperModel() {
+  if (process.env.JARVIS_WHISPER_MODEL) return process.env.JARVIS_WHISPER_MODEL;
+  const dir = path.join(os.homedir(), 'whisper-models');
+  const prefer = ['ggml-medium.bin', 'ggml-small.bin', 'ggml-base.bin'];
+  for (const f of prefer) {
+    const p = path.join(dir, f);
+    if (fs.existsSync(p)) return p;
+  }
+  return path.join(dir, 'ggml-base.bin');
+}
+const WHISPER_MODEL = pickWhisperModel();
+
+const SYSTEM_PROMPT = `You are J.A.R.V.I.S. (Just A Rather Very Intelligent System), the AI assistant from Iron Man. You are highly intelligent, efficient, and professional, with a touch of refined British wit.
+
+Critical rules:
+- Your responses will be spoken aloud by a text-to-speech engine. Be concise and conversational. No markdown, no bullet points, no asterisks, no code blocks in your verbal responses.
+- You can use the Bash tool to execute commands on the user's Mac for real tasks.
+- Respond in the same language the user speaks (French or English).
+- When you run commands, briefly describe what you are doing in natural speech.
+- Address the user respectfully.`;
+
+// ============================================================
+// LOCAL HTTP SERVER (sert le renderer sur http://localhost — requis
+// pour que l'API getUserMedia fonctionne dans un contexte sécurisé)
+// ============================================================
+
+function startLocalServer() {
+  const mime = { '.html': 'text/html', '.css': 'text/css', '.js': 'text/javascript' };
+  http.createServer((req, res) => {
+    const url = req.url.split('?')[0];
+
+    if (url.startsWith('/whisper/')) {
+      const proxyReq = http.request({
+        host:    '127.0.0.1',
+        port:    WHISPER_PORT,
+        method:  req.method,
+        path:    url.replace('/whisper', ''),
+        headers: req.headers,
+      }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode, proxyRes.headers);
+        proxyRes.pipe(res);
+      });
+      proxyReq.on('error', (e) => { res.writeHead(502); res.end(e.message); });
+      req.pipe(proxyReq);
+      return;
+    }
+
+    const filePath = path.join(__dirname, url === '/' ? 'index.html' : url);
+    fs.readFile(filePath, (err, data) => {
+      if (err) { res.writeHead(404); res.end('Not found'); return; }
+      res.writeHead(200, { 'Content-Type': mime[path.extname(filePath)] || 'text/plain' });
+      res.end(data);
+    });
+  }).listen(PORT, '127.0.0.1');
+}
+
+// ============================================================
+// WHISPER SERVER (daemon local, modèle chargé une seule fois)
+// ============================================================
+
+let whisperProc = null;
+
+function startWhisperServer() {
+  if (!fs.existsSync(WHISPER_MODEL)) {
+    console.error('[JARVIS] modèle Whisper introuvable :', WHISPER_MODEL);
+    console.error('[JARVIS] Télécharge-le avec :');
+    console.error('  mkdir -p ~/whisper-models && curl -L -o ~/whisper-models/ggml-base.bin \\');
+    console.error('    https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin');
+    return false;
+  }
+
+  const whisperBin = findBin('whisper-server');
+  if (!whisperBin) {
+    console.error('[JARVIS] whisper-server introuvable dans le PATH. Installe-le avec : brew install whisper-cpp');
+    return false;
+  }
+  console.log('[JARVIS] whisper binary :', whisperBin);
+
+  whisperProc = spawn(whisperBin, [
+    '-m',      WHISPER_MODEL,
+    '--host',  '127.0.0.1',
+    '--port',  String(WHISPER_PORT),
+    '-l',      'auto',
+    '-nt',
+    '-t',      '6',
+  ], { stdio: ['ignore', 'pipe', 'pipe'] });
+
+  whisperProc.on('error', (e) => {
+    console.error('[JARVIS] whisper-server spawn error :', e.message);
+    whisperProc = null;
+  });
+  whisperProc.stdout.on('data', d => process.stdout.write('[whisper] ' + d));
+  whisperProc.stderr.on('data', d => process.stderr.write('[whisper] ' + d));
+  whisperProc.on('exit', (code) => {
+    console.log('[JARVIS] whisper-server terminé, code =', code);
+    whisperProc = null;
+  });
+  return true;
+}
+
+function stopWhisperServer() {
+  if (whisperProc) {
+    try { whisperProc.kill('SIGTERM'); } catch (_) {}
+    whisperProc = null;
+  }
+}
+
+// ============================================================
+// CLAUDE CLI
+// ============================================================
+
+function findBin(name, extraCandidates = []) {
+  try {
+    const result = execSync(`/bin/zsh --login -c "which ${name}"`, {
+      encoding: 'utf8',
+      timeout:  5000,
+    }).trim();
+    if (result && fs.existsSync(result)) return result;
+  } catch (_) {}
+
+  const candidates = [
+    `/opt/homebrew/bin/${name}`,
+    `/usr/local/bin/${name}`,
+    `/usr/bin/${name}`,
+    `${os.homedir()}/.local/bin/${name}`,
+    ...extraCandidates,
+  ];
+  for (const p of candidates) {
+    try { fs.accessSync(p, fs.constants.X_OK); return p; } catch (_) {}
+  }
+  return null;
+}
+
+function findClaudeBin() {
+  return findBin('claude', [`${os.homedir()}/.npm-global/bin/claude`]) || 'claude';
+}
+
+const CLAUDE_BIN = findClaudeBin();
+console.log('[JARVIS] claude binary :', CLAUDE_BIN);
+
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '').trim();
+}
+
+function buildPrompt(userMessage) {
+  let prompt = SYSTEM_PROMPT + '\n\n';
+  if (history.length > 0) {
+    prompt += 'CONVERSATION HISTORY:\n';
+    for (const msg of history) {
+      const label = msg.role === 'user' ? 'USER' : 'JARVIS';
+      prompt += `${label}: ${msg.content}\n`;
+    }
+    prompt += '\n';
+  }
+  prompt += `USER: ${userMessage}\n\nJARVIS:`;
+  return prompt;
+}
+
+const CLAUDE_CWD = '/Users/david/Documents/jarvis_result';
+
+function ensureClaudeCwd() {
+  try {
+    if (!fs.existsSync(CLAUDE_CWD)) {
+      fs.mkdirSync(CLAUDE_CWD, { recursive: true });
+      console.log('[JARVIS] créé dossier', CLAUDE_CWD);
+    }
+  } catch (e) {
+    console.error('[JARVIS] impossible de créer', CLAUDE_CWD, ':', e.message);
+  }
+}
+
+async function askClaude(userMessage) {
+  const prompt = buildPrompt(userMessage);
+  ensureClaudeCwd();
+
+  // PATH enrichi pour que Claude trouve git, node, gh, etc. même en mode .app
+  const env = {
+    ...process.env,
+    PATH: [
+      '/opt/homebrew/bin',
+      '/usr/local/bin',
+      '/usr/bin',
+      '/bin',
+      `${os.homedir()}/.local/bin`,
+      `${os.homedir()}/.npm-global/bin`,
+      process.env.PATH || '',
+    ].join(':'),
+    HOME: os.homedir(),
+  };
+
+  return new Promise((resolve) => {
+    const args = [
+      '-p', prompt,
+      '--output-format', 'text',
+      '--model', 'opus',
+      '--allowed-tools', 'Bash',
+      '--dangerously-skip-permissions',
+    ];
+
+    execFile(CLAUDE_BIN, args, {
+      timeout:   120000,
+      maxBuffer: 2 * 1024 * 1024,
+      cwd:       CLAUDE_CWD,
+      env,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        console.error('[JARVIS claude error]', err.message, stderr);
+        resolve({ success: false, error: err.message || stderr });
+        return;
+      }
+      const response = stripAnsi(stdout);
+      console.log('[JARVIS response]', response.slice(0, 200));
+      history.push({ role: 'user',      content: userMessage });
+      history.push({ role: 'assistant', content: response    });
+      if (history.length > 20) history = history.slice(-20);
+      resolve({ success: true, response });
+    });
+  });
+}
+
+// ============================================================
+// STATE
+// ============================================================
+
+let mainWin     = null;
+let speakProc   = null;
+let alwaysOnTop = true;
+let history     = [];
+let BEST_VOICE_FR = null;
+let BEST_VOICE_EN = null;
+
+function pickBestVoices() {
+  try {
+    const out = execSync('/usr/bin/say -v "?"', { encoding: 'utf8', timeout: 5000 });
+    const lines = out.split('\n').filter(Boolean);
+    const parse = lines.map(l => {
+      const m = l.match(/^(.+?)\s+([a-z]{2}[-_][A-Z]{2})\s+/);
+      if (!m) return null;
+      const name = m[1].trim();
+      const lang = m[2];
+      const premium  = /\(Premium\)/i.test(name);
+      const enhanced = /\(Enhanced\)/i.test(name);
+      return { name, lang, premium, enhanced };
+    }).filter(Boolean);
+
+    const rank = v => (v.premium ? 3 : v.enhanced ? 2 : 1);
+    const fr = parse.filter(v => v.lang.startsWith('fr')).sort((a, b) => rank(b) - rank(a))[0];
+    const en = parse.filter(v => v.lang.startsWith('en')).sort((a, b) => rank(b) - rank(a))[0];
+    BEST_VOICE_FR = fr ? fr.name : null;
+    BEST_VOICE_EN = en ? en.name : null;
+    console.log('[JARVIS] voix FR :', BEST_VOICE_FR, '| voix EN :', BEST_VOICE_EN);
+  } catch (e) {
+    console.error('[JARVIS] pickBestVoices :', e.message);
+  }
+}
+
+// ============================================================
+// WINDOW
+// ============================================================
+
+function createWindow() {
+  mainWin = new BrowserWindow({
+    width:       560,
+    height:      600,
+    transparent: true,
+    frame:       false,
+    alwaysOnTop: true,
+    hasShadow:   false,
+    backgroundColor: '#00000000',
+    resizable:   false,
+    webPreferences: {
+      preload:          path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration:  false,
+      sandbox:          false,
+    },
+  });
+
+  mainWin.setAlwaysOnTop(true, 'floating');
+  mainWin.center();
+  mainWin.loadURL(`http://localhost:${PORT}`);
+  mainWin.webContents.on('render-process-gone', (_e, d) => console.error('[JARVIS renderer gone]', d));
+  mainWin.webContents.on('did-fail-load', (_e, code, desc) => console.error('[JARVIS load fail]', code, desc));
+
+  mainWin.webContents.session.setPermissionRequestHandler((_wc, permission, callback) => {
+    callback(['microphone', 'media', 'audioCapture'].includes(permission));
+  });
+  mainWin.webContents.session.setPermissionCheckHandler((_wc, permission) => {
+    return ['microphone', 'media', 'audioCapture'].includes(permission);
+  });
+
+  mainWin.on('closed', () => { mainWin = null; });
+}
+
+// ============================================================
+// IPC
+// ============================================================
+
+ipcMain.handle('askClaude', async (_event, message) => askClaude(message));
+
+ipcMain.handle('whisperUrl', () => `http://localhost:${PORT}/whisper/inference`);
+
+ipcMain.handle('setDockIcon', (_event, dataUrl) => {
+  try {
+    const img = nativeImage.createFromDataURL(dataUrl);
+    if (!img.isEmpty() && app.dock) app.dock.setIcon(img);
+    if (mainWin) mainWin.setIcon(img);
+  } catch (e) {
+    console.error('[JARVIS] setDockIcon :', e.message);
+  }
+});
+
+ipcMain.handle('speak', async (_event, text) => {
+  if (!text) return;
+  if (speakProc) { speakProc.kill('SIGTERM'); speakProc = null; }
+
+  const frPattern = /\b(je|tu|il|elle|nous|vous|ils|le|la|les|un|une|des|est|sont|avec|pour|dans|sur|qui|que|très|aussi|mais|patron|bonjour|merci|oui|non|votre|notre)\b/i;
+  const isFr = frPattern.test(text);
+  const voice = isFr ? (BEST_VOICE_FR || 'Thomas') : (BEST_VOICE_EN || 'Alex');
+
+  return new Promise((resolve) => {
+    speakProc = spawn('/usr/bin/say', ['-v', voice, '-r', '185', text]);
+    speakProc.on('close',  (code) => { console.log('[say] exit', code, 'voice=', voice); speakProc = null; resolve(); });
+    speakProc.on('error', (e) => { speakProc = null; console.error('[say]', e.message); resolve(); });
+  });
+});
+
+ipcMain.handle('stopSpeak', () => {
+  if (speakProc) { speakProc.kill('SIGTERM'); speakProc = null; }
+});
+
+ipcMain.handle('showContextMenu', () => {
+  const menu = Menu.buildFromTemplate([
+    {
+      label: `${alwaysOnTop ? '✓' : '  '} Toujours au-dessus / Always on Top`,
+      click: () => {
+        alwaysOnTop = !alwaysOnTop;
+        mainWin?.setAlwaysOnTop(alwaysOnTop, 'floating');
+      },
+    },
+    { type: 'separator' },
+    { label: 'Effacer historique / Clear History', click: () => { history = []; } },
+    { type: 'separator' },
+    { label: 'Quitter / Quit JARVIS', click: () => app.quit() },
+  ]);
+  menu.popup({ window: mainWin });
+});
+
+// ============================================================
+// LIFECYCLE
+// ============================================================
+
+app.disableHardwareAcceleration();
+app.commandLine.appendSwitch('disable-features', 'WebRtcHideLocalIpsWithMdns,HardwareMediaKeyHandling,MediaSessionService');
+app.commandLine.appendSwitch('no-sandbox');
+
+app.whenReady().then(async () => {
+  try {
+    const status = systemPreferences.getMediaAccessStatus('microphone');
+    console.log('[JARVIS] mic access status :', status);
+    if (status !== 'granted') {
+      const ok = await systemPreferences.askForMediaAccess('microphone');
+      console.log('[JARVIS] mic access granted :', ok);
+    }
+  } catch (e) {
+    console.error('[JARVIS] mic permission error :', e.message);
+  }
+  pickBestVoices();
+  ensureClaudeCwd();
+  startLocalServer();
+  startWhisperServer();
+  createWindow();
+  globalShortcut.register('CommandOrControl+Q', () => app.quit());
+});
+
+app.on('before-quit', () => {
+  stopWhisperServer();
+  if (speakProc) { try { speakProc.kill('SIGTERM'); } catch (_) {} }
+});
+
+app.on('window-all-closed', () => {
+  globalShortcut.unregisterAll();
+  app.quit();
+});
+
+app.on('activate', () => {
+  if (!mainWin) createWindow();
+});
--- a/node_modules/.bin/asar
+++ b/node_modules/.bin/asar
@ -0,0 +1 @@
+../@electron/asar/bin/asar.js
--- a/node_modules/.bin/color-support
+++ b/node_modules/.bin/color-support
@ -0,0 +1 @@
+../color-support/bin.js
--- a/node_modules/.bin/crc32
+++ b/node_modules/.bin/crc32
@ -0,0 +1 @@
+../crc-32/bin/crc32.njs
--- a/node_modules/.bin/dmg-license
+++ b/node_modules/.bin/dmg-license
@ -0,0 +1 @@
+../dmg-license/bin/dmg-license.js
--- a/node_modules/.bin/ejs
+++ b/node_modules/.bin/ejs
@ -0,0 +1 @@
+../ejs/bin/cli.js
--- a/node_modules/.bin/electron
+++ b/node_modules/.bin/electron
@ -0,0 +1 @@
+../electron/cli.js
--- a/node_modules/.bin/electron-builder
+++ b/node_modules/.bin/electron-builder
@ -0,0 +1 @@
+../electron-builder/cli.js
--- a/node_modules/.bin/electron-osx-flat
+++ b/node_modules/.bin/electron-osx-flat
@ -0,0 +1 @@
+../@electron/osx-sign/bin/electron-osx-flat.js
--- a/node_modules/.bin/electron-osx-sign
+++ b/node_modules/.bin/electron-osx-sign
@ -0,0 +1 @@
+../@electron/osx-sign/bin/electron-osx-sign.js
--- a/node_modules/.bin/electron-rebuild
+++ b/node_modules/.bin/electron-rebuild
@ -0,0 +1 @@
+../@electron/rebuild/lib/cli.js
--- a/node_modules/.bin/extract-zip
+++ b/node_modules/.bin/extract-zip
@ -0,0 +1 @@
+../extract-zip/cli.js
--- a/node_modules/.bin/install-app-deps
+++ b/node_modules/.bin/install-app-deps
@ -0,0 +1 @@
+../electron-builder/install-app-deps.js
--- a/node_modules/.bin/is-ci
+++ b/node_modules/.bin/is-ci
@ -0,0 +1 @@
+../is-ci/bin.js
--- a/node_modules/.bin/jake
+++ b/node_modules/.bin/jake
@ -0,0 +1 @@
+../jake/bin/cli.js
--- a/node_modules/.bin/js-yaml
+++ b/node_modules/.bin/js-yaml
@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js
--- a/node_modules/.bin/json5
+++ b/node_modules/.bin/json5
@ -0,0 +1 @@
+../json5/lib/cli.js
--- a/node_modules/.bin/mime
+++ b/node_modules/.bin/mime
@ -0,0 +1 @@
+../mime/cli.js
--- a/node_modules/.bin/mkdirp
+++ b/node_modules/.bin/mkdirp
@ -0,0 +1 @@
+../mkdirp/bin/cmd.js
--- a/node_modules/.bin/node-gyp
+++ b/node_modules/.bin/node-gyp
@ -0,0 +1 @@
+../node-gyp/bin/node-gyp.js
--- a/node_modules/.bin/node-which
+++ b/node_modules/.bin/node-which
@ -0,0 +1 @@
+../which/bin/node-which
--- a/node_modules/.bin/nopt
+++ b/node_modules/.bin/nopt
@ -0,0 +1 @@
+../nopt/bin/nopt.js
--- a/node_modules/.bin/read-binary-file-arch
+++ b/node_modules/.bin/read-binary-file-arch
@ -0,0 +1 @@
+../read-binary-file-arch/cli.js
--- a/node_modules/.bin/rimraf
+++ b/node_modules/.bin/rimraf
@ -0,0 +1 @@
+../rimraf/bin.js
--- a/node_modules/.bin/semver
+++ b/node_modules/.bin/semver
@ -0,0 +1 @@
+../semver/bin/semver.js
--- a/node_modules/.bin/tsc
+++ b/node_modules/.bin/tsc
@ -0,0 +1 @@
+../typescript/bin/tsc
--- a/node_modules/.bin/tsserver
+++ b/node_modules/.bin/tsserver
@ -0,0 +1 @@
+../typescript/bin/tsserver
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
--- a/node_modules/7zip-bin/7x.sh
+++ b/node_modules/7zip-bin/7x.sh
@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+sz_program=${SZA_PATH:-7za}
+sz_type=${SZA_ARCHIVE_TYPE:-xz}
+
+case $1 in
+  -d) "$sz_program" e -si -so -t${sz_type} ;;
+   *) "$sz_program" a f -si -so -t${sz_type} -mx${SZA_COMPRESSION_LEVEL:-9} ;;
+esac 2> /dev/null
--- a/node_modules/7zip-bin/LICENSE.txt
+++ b/node_modules/7zip-bin/LICENSE.txt
@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Vladimir Krivosheev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
--- a/node_modules/7zip-bin/README.md
+++ b/node_modules/7zip-bin/README.md
@ -0,0 +1 @@
+7-Zip precompiled binaries.
--- a/node_modules/7zip-bin/index.d.ts
+++ b/node_modules/7zip-bin/index.d.ts
@ -0,0 +1,2 @@
+export const path7za: string
+export const path7x: string
--- a/node_modules/7zip-bin/index.js
+++ b/node_modules/7zip-bin/index.js
@ -0,0 +1,22 @@
+"use strict"
+
+const path = require("path")
+
+function getPath() {
+  if (process.env.USE_SYSTEM_7ZA === "true") {
+    return "7za"
+  }
+
+  if (process.platform === "darwin") {
+    return path.join(__dirname, "mac", process.arch, "7za")
+  }
+  else if (process.platform === "win32") {
+    return path.join(__dirname, "win", process.arch, "7za.exe")
+  }
+  else {
+    return path.join(__dirname, "linux", process.arch, "7za")
+  }
+}
+
+exports.path7za = getPath()
+exports.path7x = path.join(__dirname, "7x.sh")
--- a/node_modules/7zip-bin/linux/arm/7za
+++ b/node_modules/7zip-bin/linux/arm/7za
--- a/node_modules/7zip-bin/linux/arm64/7za
+++ b/node_modules/7zip-bin/linux/arm64/7za
--- a/node_modules/7zip-bin/linux/ia32/7za
+++ b/node_modules/7zip-bin/linux/ia32/7za
--- a/node_modules/7zip-bin/linux/x64/7za
+++ b/node_modules/7zip-bin/linux/x64/7za
--- a/node_modules/7zip-bin/linux/x64/build.sh
+++ b/node_modules/7zip-bin/linux/x64/build.sh
@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -e
+
+BASEDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+rm -rf /tmp/7z-linux
+mkdir /tmp/7z-linux
+cp "$BASEDIR/do-build.sh" /tmp/7z-linux/do-build.sh
+docker run --rm -v /tmp/7z-linux:/project buildpack-deps:xenial /project/do-build.sh
--- a/node_modules/7zip-bin/linux/x64/do-build.sh
+++ b/node_modules/7zip-bin/linux/x64/do-build.sh
@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -e
+
+apt-get update -qq
+apt-get upgrade -qq
+
+echo "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-5.0 main" > /etc/apt/sources.list.d/llvm.list
+curl -L http://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
+apt-get update -qq
+apt-get install -qq bzip2 yasm clang-5.0 lldb-5.0 lld-5.0
+
+ln -s /usr/bin/clang-5.0 /usr/bin/clang
+ln -s /usr/bin/clang++-5.0 /usr/bin/clang++
+
+mkdir -p /tmp/7z
+cd /tmp/7z
+curl -L http://downloads.sourceforge.net/project/p7zip/p7zip/16.02/p7zip_16.02_src_all.tar.bz2 | tar -xj -C . --strip-components 1
+cp makefile.linux_clang_amd64_asm makefile.machine
+make -j4
+mv bin/7za /project/7za
--- a/node_modules/7zip-bin/mac/arm64/7za
+++ b/node_modules/7zip-bin/mac/arm64/7za
--- a/node_modules/7zip-bin/mac/x64/7za
+++ b/node_modules/7zip-bin/mac/x64/7za
--- a/node_modules/7zip-bin/package.json
+++ b/node_modules/7zip-bin/package.json
@ -0,0 +1,20 @@
+{
+  "name": "7zip-bin",
+  "description": "7-Zip precompiled binaries",
+  "version": "5.2.0",
+  "files": [
+    "*.js",
+    "7x.sh",
+    "index.d.ts",
+    "linux",
+    "mac",
+    "win"
+  ],
+  "license": "MIT",
+  "repository": "develar/7zip-bin",
+  "keywords": [
+    "7zip",
+    "7z",
+    "7za"
+  ]
+}
--- a/node_modules/7zip-bin/win/arm64/7za.exe
+++ b/node_modules/7zip-bin/win/arm64/7za.exe
--- a/node_modules/7zip-bin/win/ia32/7za.exe
+++ b/node_modules/7zip-bin/win/ia32/7za.exe
--- a/node_modules/7zip-bin/win/x64/7za.exe
+++ b/node_modules/7zip-bin/win/x64/7za.exe
--- a/node_modules/@develar/schema-utils/CHANGELOG.md
+++ b/node_modules/@develar/schema-utils/CHANGELOG.md
@ -0,0 +1,259 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [2.6.5](https://github.com/webpack/schema-utils/compare/v2.6.4...v2.6.5) (2020-03-11)
+
+
+### Bug Fixes
+
+* typo ([#88](https://github.com/webpack/schema-utils/issues/88)) ([52fc92b](https://github.com/webpack/schema-utils/commit/52fc92b531b7503b7bbe1bf9b21bfa26dffbc8f5))
+
+### [2.6.4](https://github.com/webpack/schema-utils/compare/v2.6.3...v2.6.4) (2020-01-17)
+
+
+### Bug Fixes
+
+* change `initialised` to `initialized` ([#87](https://github.com/webpack/schema-utils/issues/87)) ([70f12d3](https://github.com/webpack/schema-utils/commit/70f12d33a8eaa27249bc9c1a27f886724cf91ea7))
+
+### [2.6.3](https://github.com/webpack/schema-utils/compare/v2.6.2...v2.6.3) (2020-01-17)
+
+
+### Bug Fixes
+
+* prefer the `baseDataPath` option from arguments ([#86](https://github.com/webpack/schema-utils/issues/86)) ([e236859](https://github.com/webpack/schema-utils/commit/e236859e85b28e35e1294f86fc1ff596a5031cea))
+
+### [2.6.2](https://github.com/webpack/schema-utils/compare/v2.6.1...v2.6.2) (2020-01-14)
+
+
+### Bug Fixes
+
+* better handle Windows absolute paths ([#85](https://github.com/webpack/schema-utils/issues/85)) ([1fa2930](https://github.com/webpack/schema-utils/commit/1fa2930a161e907b9fc53a7233d605910afdb883))
+
+### [2.6.1](https://github.com/webpack/schema-utils/compare/v2.6.0...v2.6.1) (2019-11-28)
+
+
+### Bug Fixes
+
+* typescript declarations ([#84](https://github.com/webpack/schema-utils/issues/84)) ([89d55a9](https://github.com/webpack/schema-utils/commit/89d55a9a8edfa6a8ac8b112f226bb3154e260319))
+
+## [2.6.0](https://github.com/webpack/schema-utils/compare/v2.5.0...v2.6.0) (2019-11-27)
+
+
+### Features
+
+* support configuration via title ([#81](https://github.com/webpack/schema-utils/issues/81)) ([afddc10](https://github.com/webpack/schema-utils/commit/afddc109f6891cd37a9f1835d50862d119a072bf))
+
+
+### Bug Fixes
+
+* typescript definitions ([#70](https://github.com/webpack/schema-utils/issues/70)) ([f38158d](https://github.com/webpack/schema-utils/commit/f38158d6d040e2c701622778ae8122fb26a4f990))
+
+## [2.5.0](https://github.com/webpack/schema-utils/compare/v2.4.1...v2.5.0) (2019-10-15)
+
+
+### Bug Fixes
+
+* rework format for maxLength, minLength ([#67](https://github.com/webpack/schema-utils/issues/67)) ([0d12259](https://github.com/webpack/schema-utils/commit/0d12259))
+* support all cases with one number in range ([#64](https://github.com/webpack/schema-utils/issues/64)) ([7fc8069](https://github.com/webpack/schema-utils/commit/7fc8069))
+* typescript definition and export naming ([#69](https://github.com/webpack/schema-utils/issues/69)) ([a435b79](https://github.com/webpack/schema-utils/commit/a435b79))
+
+
+### Features
+
+* "smart" numbers range ([62fb107](https://github.com/webpack/schema-utils/commit/62fb107))
+
+### [2.4.1](https://github.com/webpack/schema-utils/compare/v2.4.0...v2.4.1) (2019-09-27)
+
+
+### Bug Fixes
+
+* publish definitions ([#58](https://github.com/webpack/schema-utils/issues/58)) ([1885faa](https://github.com/webpack/schema-utils/commit/1885faa))
+
+## [2.4.0](https://github.com/webpack/schema-utils/compare/v2.3.0...v2.4.0) (2019-09-26)
+
+
+### Features
+
+* better errors when the `type` keyword doesn't exist ([0988be2](https://github.com/webpack/schema-utils/commit/0988be2))
+* support $data reference ([#56](https://github.com/webpack/schema-utils/issues/56)) ([d2f11d6](https://github.com/webpack/schema-utils/commit/d2f11d6))
+* types definitions ([#52](https://github.com/webpack/schema-utils/issues/52)) ([facb431](https://github.com/webpack/schema-utils/commit/facb431))
+
+## [2.3.0](https://github.com/webpack/schema-utils/compare/v2.2.0...v2.3.0) (2019-09-26)
+
+
+### Features
+
+* support `not` keyword ([#53](https://github.com/webpack/schema-utils/issues/53)) ([765f458](https://github.com/webpack/schema-utils/commit/765f458))
+
+## [2.2.0](https://github.com/webpack/schema-utils/compare/v2.1.0...v2.2.0) (2019-09-02)
+
+
+### Features
+
+* better error output for `oneOf` and `anyOf` ([#48](https://github.com/webpack/schema-utils/issues/48)) ([#50](https://github.com/webpack/schema-utils/issues/50)) ([332242f](https://github.com/webpack/schema-utils/commit/332242f))
+
+## [2.1.0](https://github.com/webpack-contrib/schema-utils/compare/v2.0.1...v2.1.0) (2019-08-07)
+
+
+### Bug Fixes
+
+* throw error on sparse arrays ([#47](https://github.com/webpack-contrib/schema-utils/issues/47)) ([b85ac38](https://github.com/webpack-contrib/schema-utils/commit/b85ac38))
+
+
+### Features
+
+* export `ValidateError` ([#46](https://github.com/webpack-contrib/schema-utils/issues/46)) ([ff781d7](https://github.com/webpack-contrib/schema-utils/commit/ff781d7))
+
+
+
+### [2.0.1](https://github.com/webpack-contrib/schema-utils/compare/v2.0.0...v2.0.1) (2019-07-18)
+
+
+### Bug Fixes
+
+* error message for empty object ([#44](https://github.com/webpack-contrib/schema-utils/issues/44)) ([0b4b4a2](https://github.com/webpack-contrib/schema-utils/commit/0b4b4a2))
+
+
+
+### [2.0.0](https://github.com/webpack-contrib/schema-utils/compare/v1.0.0...v2.0.0) (2019-07-17)
+
+
+### BREAKING CHANGES
+
+* drop support for Node.js < 8.9.0
+* drop support `errorMessage`, please use `description` for links.
+* api was changed, please look documentation.
+* error messages was fully rewritten.
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/webpack-contrib/schema-utils/compare/v0.4.7...v1.0.0) (2018-08-07)
+
+
+### Features
+
+* **src:** add support for custom error messages ([#33](https://github.com/webpack-contrib/schema-utils/issues/33)) ([1cbe4ef](https://github.com/webpack-contrib/schema-utils/commit/1cbe4ef))
+
+
+
+<a name="0.4.7"></a>
+## [0.4.7](https://github.com/webpack-contrib/schema-utils/compare/v0.4.6...v0.4.7) (2018-08-07)
+
+
+### Bug Fixes
+
+* **src:** `node >= v4.0.0` support ([#32](https://github.com/webpack-contrib/schema-utils/issues/32)) ([cb13dd4](https://github.com/webpack-contrib/schema-utils/commit/cb13dd4))
+
+
+
+<a name="0.4.6"></a>
+## [0.4.6](https://github.com/webpack-contrib/schema-utils/compare/v0.4.5...v0.4.6) (2018-08-06)
+
+
+### Bug Fixes
+
+* **package:** remove lockfile ([#28](https://github.com/webpack-contrib/schema-utils/issues/28)) ([69f1a81](https://github.com/webpack-contrib/schema-utils/commit/69f1a81))
+* **package:** remove unnecessary `webpack` dependency ([#26](https://github.com/webpack-contrib/schema-utils/issues/26)) ([532eaa5](https://github.com/webpack-contrib/schema-utils/commit/532eaa5))
+
+
+
+<a name="0.4.5"></a>
+## [0.4.5](https://github.com/webpack-contrib/schema-utils/compare/v0.4.4...v0.4.5) (2018-02-13)
+
+
+### Bug Fixes
+
+* **CHANGELOG:** update broken links ([4483b9f](https://github.com/webpack-contrib/schema-utils/commit/4483b9f))
+* **package:** update broken links ([f2494ba](https://github.com/webpack-contrib/schema-utils/commit/f2494ba))
+
+
+
+<a name="0.4.4"></a>
+## [0.4.4](https://github.com/webpack-contrib/schema-utils/compare/v0.4.3...v0.4.4) (2018-02-13)
+
+
+### Bug Fixes
+
+* **package:** update `dependencies` ([#22](https://github.com/webpack-contrib/schema-utils/issues/22)) ([3aecac6](https://github.com/webpack-contrib/schema-utils/commit/3aecac6))
+
+
+
+<a name="0.4.3"></a>
+## [0.4.3](https://github.com/webpack-contrib/schema-utils/compare/v0.4.2...v0.4.3) (2017-12-14)
+
+
+### Bug Fixes
+
+* **validateOptions:** throw `err` instead of `process.exit(1)` ([#17](https://github.com/webpack-contrib/schema-utils/issues/17)) ([c595eda](https://github.com/webpack-contrib/schema-utils/commit/c595eda))
+* **ValidationError:** never return `this` in the ctor ([#16](https://github.com/webpack-contrib/schema-utils/issues/16)) ([c723791](https://github.com/webpack-contrib/schema-utils/commit/c723791))
+
+
+
+<a name="0.4.2"></a>
+## [0.4.2](https://github.com/webpack-contrib/schema-utils/compare/v0.4.1...v0.4.2) (2017-11-09)
+
+
+### Bug Fixes
+
+* **validateOptions:** catch `ValidationError` and handle it internally ([#15](https://github.com/webpack-contrib/schema-utils/issues/15)) ([9c5ef5e](https://github.com/webpack-contrib/schema-utils/commit/9c5ef5e))
+
+
+
+<a name="0.4.1"></a>
+## [0.4.1](https://github.com/webpack-contrib/schema-utils/compare/v0.4.0...v0.4.1) (2017-11-03)
+
+
+### Bug Fixes
+
+* **ValidationError:** use `Error.captureStackTrace` for `err.stack` handling ([#14](https://github.com/webpack-contrib/schema-utils/issues/14)) ([a6fb974](https://github.com/webpack-contrib/schema-utils/commit/a6fb974))
+
+
+
+<a name="0.4.0"></a>
+# [0.4.0](https://github.com/webpack-contrib/schema-utils/compare/v0.3.0...v0.4.0) (2017-10-28)
+
+
+### Features
+
+* add support for `typeof`, `instanceof` (`{Function\|RegExp}`) ([#10](https://github.com/webpack-contrib/schema-utils/issues/10)) ([9f01816](https://github.com/webpack-contrib/schema-utils/commit/9f01816))
+
+
+
+<a name="0.3.0"></a>
+# [0.3.0](https://github.com/webpack-contrib/schema-utils/compare/v0.2.1...v0.3.0) (2017-04-29)
+
+
+### Features
+
+* add ValidationError ([#8](https://github.com/webpack-contrib/schema-utils/issues/8)) ([d48f0fb](https://github.com/webpack-contrib/schema-utils/commit/d48f0fb))
+
+
+
+<a name="0.2.1"></a>
+## [0.2.1](https://github.com/webpack-contrib/schema-utils/compare/v0.2.0...v0.2.1) (2017-03-13)
+
+
+### Bug Fixes
+
+* Include .babelrc to `files` ([28f0363](https://github.com/webpack-contrib/schema-utils/commit/28f0363))
+* Include source to `files` ([43b0f2f](https://github.com/webpack-contrib/schema-utils/commit/43b0f2f))
+
+
+
+<a name="0.2.0"></a>
+# [0.2.0](https://github.com/webpack-contrib/schema-utils/compare/v0.1.0...v0.2.0) (2017-03-12)
+
+<a name="0.1.0"></a>
+# 0.1.0 (2017-03-07)
+
+
+### Features
+
+* **validations:** add validateOptions module ([ae9b47b](https://github.com/webpack-contrib/schema-utils/commit/ae9b47b))
+
+
+
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
--- a/node_modules/@develar/schema-utils/LICENSE
+++ b/node_modules/@develar/schema-utils/LICENSE
@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@develar/schema-utils/README.md
+++ b/node_modules/@develar/schema-utils/README.md
@ -0,0 +1,276 @@
+<div align="center">
+  <a href="http://json-schema.org">
+    <img width="160" height="160"
+      src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
+  </a>
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# schema-utils
+
+Package for validate options in loaders and plugins.
+
+## Getting Started
+
+To begin, you'll need to install `schema-utils`:
+
+```console
+npm install schema-utils
+```
+
+## API
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "option": {
+      "type": ["boolean"]
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+```js
+import schema from './path/to/schema.json';
+import validate from 'schema-utils';
+
+const options = { option: true };
+const configuration = { name: 'Loader Name/Plugin Name/Name' };
+
+validate(schema, options, configuration);
+```
+
+### `schema`
+
+Type: `String`
+
+JSON schema.
+
+Simple example of schema:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `options`
+
+Type: `Object`
+
+Object with options.
+
+```js
+validate(
+  schema,
+  {
+    name: 123,
+  },
+  { name: 'MyPlugin' }
+);
+```
+
+### `configuration`
+
+Allow to configure validator.
+
+There is an alternative method to configure the `name` and`baseDataPath` options via the `title` property in the schema.
+For example:
+
+```json
+{
+  "title": "My Loader options",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+The last word used for the `baseDataPath` option, other words used for the `name` option.
+Based on the example above the `name` option equals `My Loader`, the `baseDataPath` option equals `options`.
+
+#### `name`
+
+Type: `Object`
+Default: `"Object"`
+
+Allow to setup name in validation errors.
+
+```js
+validate(schema, options, { name: 'MyPlugin' });
+```
+
+```shell
+Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
+ - configuration.optionName should be a integer.
+```
+
+#### `baseDataPath`
+
+Type: `String`
+Default: `"configuration"`
+
+Allow to setup base data path in validation errors.
+
+```js
+validate(schema, options, { name: 'MyPlugin', baseDataPath: 'options' });
+```
+
+```shell
+Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+```
+
+#### `postFormatter`
+
+Type: `Function`
+Default: `undefined`
+
+Allow to reformat errors.
+
+```js
+validate(schema, options, {
+  name: 'MyPlugin',
+  postFormatter: (formattedError, error) => {
+    if (error.keyword === 'type') {
+      return `${formattedError}\nAdditional Information.`;
+    }
+
+    return formattedError;
+  },
+});
+```
+
+```shell
+Invalid options object. MyPlugin has been initialized using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+   Additional Information.
+```
+
+## Examples
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "test": {
+      "anyOf": [
+        { "type": "array" },
+        { "type": "string" },
+        { "instanceof": "RegExp" }
+      ]
+    },
+    "transform": {
+      "instanceof": "Function"
+    },
+    "sourceMap": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `Loader`
+
+```js
+import { getOptions } from 'loader-utils';
+import validateOptions from 'schema-utils';
+
+import schema from 'path/to/schema.json';
+
+function loader(src, map) {
+  const options = getOptions(this) || {};
+
+  validateOptions(schema, options, {
+    name: 'Loader Name',
+    baseDataPath: 'options',
+  });
+
+  // Code...
+}
+
+export default loader;
+```
+
+### `Plugin`
+
+```js
+import validateOptions from 'schema-utils';
+
+import schema from 'path/to/schema.json';
+
+class Plugin {
+  constructor(options) {
+    validateOptions(schema, options, {
+      name: 'Plugin Name',
+      baseDataPath: 'options',
+    });
+
+    this.options = options;
+  }
+
+  apply(compiler) {
+    // Code...
+  }
+}
+
+export default Plugin;
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/schema-utils.svg
+[npm-url]: https://npmjs.com/package/schema-utils
+[node]: https://img.shields.io/node/v/schema-utils.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack/schema-utils.svg
+[deps-url]: https://david-dm.org/webpack/schema-utils
+[tests]: https://dev.azure.com/webpack/schema-utils/_apis/build/status/webpack.schema-utils?branchName=master
+[tests-url]: https://dev.azure.com/webpack/schema-utils/_build/latest?definitionId=9&branchName=master
+[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/schema-utils
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=schema-utils
+[size-url]: https://packagephobia.now.sh/result?p=schema-utils
--- a/node_modules/@develar/schema-utils/declarations/ValidationError.d.ts
+++ b/node_modules/@develar/schema-utils/declarations/ValidationError.d.ts
@ -0,0 +1,115 @@
+export default ValidationError;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type Schema =
+  | import('json-schema').JSONSchema4
+  | import('json-schema').JSONSchema6
+  | import('json-schema').JSONSchema7;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: import('./validate').PostFormatter | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: import('ajv').ErrorObject & {
+    children?: import('ajv').ErrorObject[] | undefined;
+  }
+) => string;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+export type SPECIFICITY = number;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: (import('ajv').ErrorObject & {
+      children?: import('ajv').ErrorObject[] | undefined;
+    })[],
+    schema:
+      | import('json-schema').JSONSchema4
+      | import('json-schema').JSONSchema6
+      | import('json-schema').JSONSchema7,
+    configuration?: import('./validate').ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(
+    path: string
+  ):
+    | import('json-schema').JSONSchema4
+    | import('json-schema').JSONSchema6
+    | import('json-schema').JSONSchema7;
+  /**
+   * @param {Schema} schema
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema:
+      | import('json-schema').JSONSchema4
+      | import('json-schema').JSONSchema6
+      | import('json-schema').JSONSchema7,
+    prevSchemas?: Object[]
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?:
+      | import('json-schema').JSONSchema4
+      | import('json-schema').JSONSchema6
+      | import('json-schema').JSONSchema7
+      | undefined,
+    additionalPath?: boolean | string[] | undefined,
+    needDot?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(
+    schemaPart?:
+      | import('json-schema').JSONSchema4
+      | import('json-schema').JSONSchema6
+      | import('json-schema').JSONSchema7
+      | undefined
+  ): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(
+    error: import('ajv').ErrorObject & {
+      children?: import('ajv').ErrorObject[] | undefined;
+    }
+  ): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(
+    errors: (import('ajv').ErrorObject & {
+      children?: import('ajv').ErrorObject[] | undefined;
+    })[]
+  ): string;
+}
--- a/node_modules/@develar/schema-utils/declarations/index.d.ts
+++ b/node_modules/@develar/schema-utils/declarations/index.d.ts
@ -0,0 +1,2 @@
+declare const _exports: typeof import('./validate').default;
+export = _exports;
--- a/node_modules/@develar/schema-utils/declarations/keywords/absolutePath.d.ts
+++ b/node_modules/@develar/schema-utils/declarations/keywords/absolutePath.d.ts
@ -0,0 +1,13 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import('ajv').Ajv;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(
+  ajv: import('ajv').Ajv
+): import('ajv').Ajv;
--- a/node_modules/@develar/schema-utils/declarations/util/Range.d.ts
+++ b/node_modules/@develar/schema-utils/declarations/util/Range.d.ts
@ -0,0 +1,43 @@
+export = Range;
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+declare class Range {
+  /** @type {Array<RangeValue>} */
+  _left: Array<RangeValue>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<RangeValue>;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic?: boolean): string;
+}
+declare namespace Range {
+  export {
+    getOperator,
+    formatRight,
+    formatLeft,
+    formatRange,
+    getRangeValue,
+    RangeValue,
+    RangeValueCallback,
+  };
+}
+type RangeValue = [number, boolean];
+type RangeValueCallback = (rangeValue: [number, boolean]) => boolean;
--- a/node_modules/@develar/schema-utils/declarations/validate.d.ts
+++ b/node_modules/@develar/schema-utils/declarations/validate.d.ts
@ -0,0 +1,43 @@
+export default validate;
+export type JSONSchema4 = import('json-schema').JSONSchema4;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type ErrorObject = Ajv.ErrorObject;
+export type Schema =
+  | import('json-schema').JSONSchema4
+  | import('json-schema').JSONSchema6
+  | import('json-schema').JSONSchema7;
+export type SchemaUtilErrorObject = Ajv.ErrorObject & {
+  children?: Ajv.ErrorObject[] | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: Ajv.ErrorObject & {
+    children?: Ajv.ErrorObject[] | undefined;
+  }
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+declare function validate(
+  schema:
+    | import('json-schema').JSONSchema4
+    | import('json-schema').JSONSchema6
+    | import('json-schema').JSONSchema7,
+  options: any,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+declare namespace validate {
+  export { ValidationError };
+  export { ValidationError as ValidateError };
+}
+import Ajv from 'ajv';
+import ValidationError from './ValidationError';
--- a/node_modules/@develar/schema-utils/dist/ValidationError.js
+++ b/node_modules/@develar/schema-utils/dist/ValidationError.js
--- a/node_modules/@develar/schema-utils/dist/index.js
+++ b/node_modules/@develar/schema-utils/dist/index.js
@ -0,0 +1,5 @@
+"use strict";
+
+const validate = require('./validate');
+
+module.exports = validate.default;
--- a/node_modules/@develar/schema-utils/dist/keywords/absolutePath.js
+++ b/node_modules/@develar/schema-utils/dist/keywords/absolutePath.js
@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** @typedef {import("ajv").Ajv} Ajv */
+
+/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/**
+ *
+ * @param {string} data
+ * @param {object} schema
+ * @param {string} message
+ * @returns {object} // Todo `returns` should be `SchemaUtilErrorObject`
+ */
+function errorMessage(message, schema, data) {
+  return {
+    keyword: 'absolutePath',
+    params: {
+      absolutePath: data
+    },
+    message,
+    parentSchema: schema
+  };
+}
+/**
+ * @param {boolean} shouldBeAbsolute
+ * @param {object} schema
+ * @param {string} data
+ * @returns {object}
+ */
+
+
+function getErrorFor(shouldBeAbsolute, schema, data) {
+  const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
+  return errorMessage(message, schema, data);
+}
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+
+
+function addAbsolutePathKeyword(ajv) {
+  ajv.addKeyword('absolutePath', {
+    errors: true,
+    type: 'string',
+
+    compile(schema, parentSchema) {
+      /**
+       * @param {any} data
+       * @returns {boolean}
+       */
+      function callback(data) {
+        let passes = true;
+        const isExclamationMarkPresent = data.includes('!');
+
+        if (isExclamationMarkPresent) {
+          callback.errors = [errorMessage(`The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`, parentSchema, data)];
+          passes = false;
+        } // ?:[A-Za-z]:\\ - Windows absolute path
+        // \\\\ - Windows network absolute path
+        // \/ - Unix-like OS absolute path
+
+
+        const isCorrectAbsolutePath = schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);
+
+        if (!isCorrectAbsolutePath) {
+          callback.errors = [getErrorFor(schema, parentSchema, data)];
+          passes = false;
+        }
+
+        return passes;
+      }
+      /** @type {null | Array<SchemaUtilErrorObject>}*/
+
+
+      callback.errors = [];
+      return callback;
+    }
+
+  });
+  return ajv;
+}
+
+var _default = addAbsolutePathKeyword;
+exports.default = _default;
--- a/node_modules/@develar/schema-utils/dist/util/Range.js
+++ b/node_modules/@develar/schema-utils/dist/util/Range.js
@ -0,0 +1,163 @@
+"use strict";
+
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === 'left') {
+      return exclusive ? '>' : '>=';
+    }
+
+    return exclusive ? '<' : '<=';
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator('right', exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator('left', exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+
+
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = 'should be';
+    result += ` ${Range.getOperator(logic ? 'left' : 'right', logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? 'and' : 'or';
+    result += ` ${Range.getOperator(logic ? 'right' : 'left', logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+
+
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ?
+    /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax :
+    /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
+
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
+    }
+
+    if (j > -1) {
+      return values[j];
+    }
+
+    return [Infinity, true];
+  }
+
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
+
+    this._right = [];
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+
+
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return '';
+    }
+
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+
+    if (realStart === realEnd) {
+      return `should be ${logic ? '' : '!'}= ${realStart}`;
+    } // e.g. 4 < x < ∞
+
+
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    } // e.g. ∞ < x < 4
+
+
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
+    }
+
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
+
+}
+
+module.exports = Range;
--- a/node_modules/@develar/schema-utils/dist/validate.js
+++ b/node_modules/@develar/schema-utils/dist/validate.js
@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _ajvKeywords = _interopRequireDefault(require("ajv-keywords"));
+
+var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
+
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7)} Schema */
+
+/** @typedef {ErrorObject & { children?: Array<ErrorObject>}} SchemaUtilErrorObject */
+
+/**
+ * @callback PostFormatter
+ * @param {string} formattedError
+ * @param {SchemaUtilErrorObject} error
+ * @returns {string}
+ */
+
+/**
+ * @typedef {Object} ValidationErrorConfiguration
+ * @property {string=} name
+ * @property {string=} baseDataPath
+ * @property {PostFormatter=} postFormatter
+ */
+const ajv = new _ajv.default({
+  allErrors: true,
+  verbose: true,
+  $data: true,
+  coerceTypes: true
+});
+(0, _ajvKeywords.default)(ajv, ['instanceof', 'formatMinimum', 'formatMaximum', 'patternRequired']); // Custom keywords
+
+(0, _absolutePath.default)(ajv);
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+
+function validate(schema, options, configuration) {
+  let errors = [];
+
+  if (Array.isArray(options)) {
+    errors = Array.from(options).map(nestedOptions => validateObject(schema, nestedOptions));
+    errors.forEach((list, idx) => {
+      const applyPrefix =
+      /**
+       * @param {SchemaUtilErrorObject} error
+       */
+      error => {
+        // eslint-disable-next-line no-param-reassign
+        error.dataPath = `[${idx}]${error.dataPath}`;
+
+        if (error.children) {
+          error.children.forEach(applyPrefix);
+        }
+      };
+
+      list.forEach(applyPrefix);
+    });
+    errors = errors.reduce((arr, items) => arr.concat(items), []);
+  } else {
+    errors = validateObject(schema, options);
+  }
+
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function validateObject(schema, options) {
+  const compiledSchema = ajv.compile(schema);
+  const valid = compiledSchema(options);
+
+  if (!compiledSchema.errors) {
+    return [];
+  }
+
+  return valid ? [] : filterErrors(compiledSchema.errors);
+}
+/**
+ * @param {Array<ErrorObject>} errors
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function filterErrors(errors) {
+  /** @type {Array<SchemaUtilErrorObject>} */
+  let newErrors = [];
+
+  for (const error of
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors) {
+    const {
+      dataPath
+    } = error;
+    /** @type {Array<SchemaUtilErrorObject>} */
+
+    let children = [];
+    newErrors = newErrors.filter(oldError => {
+      if (oldError.dataPath.includes(dataPath)) {
+        if (oldError.children) {
+          children = children.concat(oldError.children.slice(0));
+        } // eslint-disable-next-line no-undefined, no-param-reassign
+
+
+        oldError.children = undefined;
+        children.push(oldError);
+        return false;
+      }
+
+      return true;
+    });
+
+    if (children.length) {
+      error.children = children;
+    }
+
+    newErrors.push(error);
+  }
+
+  return newErrors;
+} // TODO change after resolve https://github.com/microsoft/TypeScript/issues/34994
+
+
+validate.ValidationError = _ValidationError.default;
+validate.ValidateError = _ValidationError.default;
+var _default = validate;
+exports.default = _default;
--- a/node_modules/@develar/schema-utils/package.json
+++ b/node_modules/@develar/schema-utils/package.json
@ -0,0 +1,78 @@
+{
+  "name": "@develar/schema-utils",
+  "version": "2.6.5",
+  "description": "webpack Validation Utils",
+  "license": "MIT",
+  "repository": "webpack/schema-utils",
+  "author": "webpack Contrib (https://github.com/webpack-contrib)",
+  "homepage": "https://github.com/webpack/schema-utils",
+  "bugs": "https://github.com/webpack/schema-utils/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/index.js",
+  "types": "declarations/index.d.ts",
+  "engines": {
+    "node": ">= 8.9.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist declarations",
+    "prebuild": "npm run clean",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit",
+    "lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build",
+    "release": "standard-version",
+    "defaults": "webpack-defaults"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "dependencies": {
+    "ajv": "^6.12.0",
+    "ajv-keywords": "^3.4.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.8.3",
+    "@babel/core": "^7.8.3",
+    "@babel/preset-env": "^7.8.3",
+    "@commitlint/cli": "^8.3.5",
+    "@commitlint/config-conventional": "^8.3.4",
+    "@types/json-schema": "^7.0.4",
+    "@webpack-contrib/defaults": "^6.3.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^24.9.0",
+    "commitlint-azure-pipelines-cli": "^1.0.3",
+    "cross-env": "^6.0.3",
+    "del": "^5.1.0",
+    "del-cli": "^3.0.0",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.9.0",
+    "eslint-plugin-import": "^2.20.0",
+    "husky": "^4.0.10",
+    "jest": "^24.9.0",
+    "jest-junit": "^10.0.0",
+    "lint-staged": "^9.5.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^1.19.1",
+    "standard-version": "^7.0.1",
+    "typescript": "^3.7.5"
+  },
+  "keywords": [
+    "webpack"
+  ]
+}
--- a/node_modules/@electron/asar/LICENSE.md
+++ b/node_modules/@electron/asar/LICENSE.md
@ -0,0 +1,20 @@
+Copyright (c) 2014 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@electron/asar/README.md
+++ b/node_modules/@electron/asar/README.md
@ -0,0 +1,208 @@
+# @electron/asar - Electron Archive
+
+[![Test](https://github.com/electron/asar/actions/workflows/test.yml/badge.svg)](https://github.com/electron/asar/actions/workflows/test.yml)
+[![npm version](http://img.shields.io/npm/v/@electron/asar.svg)](https://npmjs.org/package/@electron/asar)
+
+Asar is a simple extensive archive format, it works like `tar` that concatenates
+all files together without compression, while having random access support.
+
+## Features
+
+* Support random access
+* Use JSON to store files' information
+* Very easy to write a parser
+
+## Command line utility
+
+### Install
+
+This module requires Node 10 or later.
+
+```bash
+$ npm install --engine-strict @electron/asar
+```
+
+### Usage
+
+```bash
+$ asar --help
+
+  Usage: asar [options] [command]
+
+  Commands:
+
+    pack|p <dir> <output>
+       create asar archive
+
+    list|l <archive>
+       list files of asar archive
+
+    extract-file|ef <archive> <filename>
+       extract one file from archive
+
+    extract|e <archive> <dest>
+       extract archive
+
+
+  Options:
+
+    -h, --help     output usage information
+    -V, --version  output the version number
+
+```
+
+#### Excluding multiple resources from being packed
+
+Given:
+```
+    app
+(a) ├── x1
+(b) ├── x2
+(c) ├── y3
+(d) │   ├── x1
+(e) │   └── z1
+(f) │       └── x2
+(g) └── z4
+(h)     └── w1
+```
+
+Exclude: a, b
+```bash
+$ asar pack app app.asar --unpack-dir "{x1,x2}"
+```
+
+Exclude: a, b, d, f
+```bash
+$ asar pack app app.asar --unpack-dir "**/{x1,x2}"
+```
+
+Exclude: a, b, d, f, h
+```bash
+$ asar pack app app.asar --unpack-dir "{**/x1,**/x2,z4/w1}"
+```
+
+## Using programmatically
+
+### Example
+
+```javascript
+const asar = require('@electron/asar');
+
+const src = 'some/path/';
+const dest = 'name.asar';
+
+await asar.createPackage(src, dest);
+console.log('done.');
+```
+
+Please note that there is currently **no** error handling provided!
+
+### Transform
+You can pass in a `transform` option, that is a function, which either returns
+nothing, or a `stream.Transform`. The latter will be used on files that will be
+in the `.asar` file to transform them (e.g. compress).
+
+```javascript
+const asar = require('@electron/asar');
+
+const src = 'some/path/';
+const dest = 'name.asar';
+
+function transform (filename) {
+  return new CustomTransformStream()
+}
+
+await asar.createPackageWithOptions(src, dest, { transform: transform });
+console.log('done.');
+```
+
+## Format
+
+Asar uses [Pickle][pickle] to safely serialize binary value to file.
+
+The format of asar is very flat:
+
+```
+| UInt32: header_size | String: header | Bytes: file1 | ... | Bytes: file42 |
+```
+
+The `header_size` and `header` are serialized with [Pickle][pickle] class, and
+`header_size`'s [Pickle][pickle] object is 8 bytes.
+
+The `header` is a JSON string, and the `header_size` is the size of `header`'s
+`Pickle` object.
+
+Structure of `header` is something like this:
+
+```json
+{
+   "files": {
+      "tmp": {
+         "files": {}
+      },
+      "usr" : {
+         "files": {
+           "bin": {
+             "files": {
+               "ls": {
+                 "offset": "0",
+                 "size": 100,
+                 "executable": true,
+                 "integrity": {
+                   "algorithm": "SHA256",
+                   "hash": "...",
+                   "blockSize": 1024,
+                   "blocks": ["...", "..."]
+                 }
+               },
+               "cd": {
+                 "offset": "100",
+                 "size": 100,
+                 "executable": true,
+                 "integrity": {
+                   "algorithm": "SHA256",
+                   "hash": "...",
+                   "blockSize": 1024,
+                   "blocks": ["...", "..."]
+                 }
+               }
+             }
+           }
+         }
+      },
+      "etc": {
+         "files": {
+           "hosts": {
+             "offset": "200",
+             "size": 32,
+             "integrity": {
+                "algorithm": "SHA256",
+                "hash": "...",
+                "blockSize": 1024,
+                "blocks": ["...", "..."]
+              }
+           }
+         }
+      }
+   }
+}
+```
+
+`offset` and `size` records the information to read the file from archive, the
+`offset` starts from 0 so you have to manually add the size of `header_size` and
+`header` to the `offset` to get the real offset of the file.
+
+`offset` is a UINT64 number represented in string, because there is no way to
+precisely represent UINT64 in JavaScript `Number`. `size` is a JavaScript
+`Number` that is no larger than `Number.MAX_SAFE_INTEGER`, which has a value of
+`9007199254740991` and is about 8PB in size. We didn't store `size` in UINT64
+because file size in Node.js is represented as `Number` and it is not safe to
+convert `Number` to UINT64.
+
+`integrity` is an object consisting of a few keys:
+* A hashing `algorithm`, currently only `SHA256` is supported.
+* A hex encoded `hash` value representing the hash of the entire file.
+* An array of hex encoded hashes for the `blocks` of the file.  i.e. for a blockSize of 4KB this array contains the hash of every block if you split the file into N 4KB blocks.
+* A integer value `blockSize` representing the size in bytes of each block in the `blocks` hashes above
+
+[pickle]: https://chromium.googlesource.com/chromium/src/+/main/base/pickle.h
--- a/node_modules/@electron/asar/bin/asar.js
+++ b/node_modules/@electron/asar/bin/asar.js
@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+var packageJSON = require('../package.json')
+var splitVersion = function (version) { return version.split('.').map(function (part) { return Number(part) }) }
+var requiredNodeVersion = splitVersion(packageJSON.engines.node.slice(2))
+var actualNodeVersion = splitVersion(process.versions.node)
+
+if (actualNodeVersion[0] < requiredNodeVersion[0] || (actualNodeVersion[0] === requiredNodeVersion[0] && actualNodeVersion[1] < requiredNodeVersion[1])) {
+  console.error('CANNOT RUN WITH NODE ' + process.versions.node)
+  console.error('asar requires Node ' + packageJSON.engines.node + '.')
+  process.exit(1)
+}
+
+// Not consts so that this file can load in Node < 4.0
+var asar = require('../lib/asar')
+var program = require('commander')
+
+program.version('v' + packageJSON.version)
+  .description('Manipulate asar archive files')
+
+program.command('pack <dir> <output>')
+  .alias('p')
+  .description('create asar archive')
+  .option('--ordering <file path>', 'path to a text file for ordering contents')
+  .option('--unpack <expression>', 'do not pack files matching glob <expression>')
+  .option('--unpack-dir <expression>', 'do not pack dirs matching glob <expression> or starting with literal <expression>')
+  .option('--exclude-hidden', 'exclude hidden files')
+  .action(function (dir, output, options) {
+    options = {
+      unpack: options.unpack,
+      unpackDir: options.unpackDir,
+      ordering: options.ordering,
+      version: options.sv,
+      arch: options.sa,
+      builddir: options.sb,
+      dot: !options.excludeHidden
+    }
+    asar.createPackageWithOptions(dir, output, options).catch(error => {
+      console.error(error)
+      process.exit(1)
+    })
+  })
+
+program.command('list <archive>')
+  .alias('l')
+  .description('list files of asar archive')
+  .option('-i, --is-pack', 'each file in the asar is pack or unpack')
+  .action(function (archive, options) {
+    options = {
+      isPack: options.isPack
+    }
+    var files = asar.listPackage(archive, options)
+    for (var i in files) {
+      console.log(files[i])
+    }
+  })
+
+program.command('extract-file <archive> <filename>')
+  .alias('ef')
+  .description('extract one file from archive')
+  .action(function (archive, filename) {
+    require('fs').writeFileSync(require('path').basename(filename),
+      asar.extractFile(archive, filename))
+  })
+
+program.command('extract <archive> <dest>')
+  .alias('e')
+  .description('extract archive')
+  .action(function (archive, dest) {
+    asar.extractAll(archive, dest)
+  })
+
+program.command('*')
+  .action(function (_cmd, args) {
+    console.log('asar: \'%s\' is not an asar command. See \'asar --help\'.', args[0])
+  })
+
+program.parse(process.argv)
+
+if (program.args.length === 0) {
+  program.help()
+}
--- a/node_modules/@electron/asar/lib/asar.d.ts
+++ b/node_modules/@electron/asar/lib/asar.d.ts
@ -0,0 +1,96 @@
+import { FilesystemDirectoryEntry, FilesystemEntry, FilesystemLinkEntry } from './filesystem';
+import * as disk from './disk';
+import { CrawledFileType } from './crawlfs';
+import { IOptions } from './types/glob';
+export declare function createPackage(src: string, dest: string): Promise<NodeJS.WritableStream>;
+export type CreateOptions = {
+    dot?: boolean;
+    globOptions?: IOptions;
+    /**
+     * Path to a file containing the list of relative filepaths relative to `src` and the specific order they should be inserted into the asar.
+     * Formats allowed below:
+     *   filepath
+     *   : filepath
+     *   <anything>:filepath
+     */
+    ordering?: string;
+    pattern?: string;
+    transform?: (filePath: string) => NodeJS.ReadWriteStream | void;
+    unpack?: string;
+    unpackDir?: string;
+};
+export declare function createPackageWithOptions(src: string, dest: string, options: CreateOptions): Promise<NodeJS.WritableStream>;
+/**
+ * Create an ASAR archive from a list of filenames.
+ *
+ * @param src - Base path. All files are relative to this.
+ * @param dest - Archive filename (& path).
+ * @param filenames - List of filenames relative to src.
+ * @param [metadata] - Object with filenames as keys and {type='directory|file|link', stat: fs.stat} as values. (Optional)
+ * @param [options] - Options passed to `createPackageWithOptions`.
+ */
+export declare function createPackageFromFiles(src: string, dest: string, filenames: string[], metadata?: disk.InputMetadata, options?: CreateOptions): Promise<NodeJS.WritableStream>;
+export type AsarStream = {
+    /**
+      Relative path to the file or directory from within the archive
+    */
+    path: string;
+    /**
+      Function that returns a read stream for a file.
+      Note: this is called multiple times per "file", so a new NodeJS.ReadableStream needs to be created each time
+    */
+    streamGenerator: () => NodeJS.ReadableStream;
+    /**
+      Whether the file/link should be unpacked
+    */
+    unpacked: boolean;
+    stat: CrawledFileType['stat'];
+};
+export type AsarDirectory = Pick<AsarStream, 'path' | 'unpacked'> & {
+    type: 'directory';
+};
+export type AsarSymlinkStream = AsarStream & {
+    type: 'link';
+    symlink: string;
+};
+export type AsarFileStream = AsarStream & {
+    type: 'file';
+};
+export type AsarStreamType = AsarDirectory | AsarFileStream | AsarSymlinkStream;
+/**
+ * Create an ASAR archive from a list of streams.
+ *
+ * @param dest - Archive filename (& path).
+ * @param streams - List of streams to be piped in-memory into asar filesystem. Insertion order is preserved.
+ */
+export declare function createPackageFromStreams(dest: string, streams: AsarStreamType[]): Promise<import("fs").WriteStream>;
+export declare function statFile(archivePath: string, filename: string, followLinks?: boolean): FilesystemEntry;
+export declare function getRawHeader(archivePath: string): disk.ArchiveHeader;
+export interface ListOptions {
+    isPack: boolean;
+}
+export declare function listPackage(archivePath: string, options: ListOptions): string[];
+export declare function extractFile(archivePath: string, filename: string, followLinks?: boolean): Buffer;
+export declare function extractAll(archivePath: string, dest: string): void;
+export declare function uncache(archivePath: string): boolean;
+export declare function uncacheAll(): void;
+export { EntryMetadata } from './filesystem';
+export { InputMetadata, DirectoryRecord, FileRecord, ArchiveHeader } from './disk';
+export type InputMetadataType = 'directory' | 'file' | 'link';
+export type DirectoryMetadata = FilesystemDirectoryEntry;
+export type FileMetadata = FilesystemEntry;
+export type LinkMetadata = FilesystemLinkEntry;
+declare const _default: {
+    createPackage: typeof createPackage;
+    createPackageWithOptions: typeof createPackageWithOptions;
+    createPackageFromFiles: typeof createPackageFromFiles;
+    createPackageFromStreams: typeof createPackageFromStreams;
+    statFile: typeof statFile;
+    getRawHeader: typeof getRawHeader;
+    listPackage: typeof listPackage;
+    extractFile: typeof extractFile;
+    extractAll: typeof extractAll;
+    uncache: typeof uncache;
+    uncacheAll: typeof uncacheAll;
+};
+export default _default;
--- a/node_modules/@electron/asar/lib/asar.js
+++ b/node_modules/@electron/asar/lib/asar.js
@ -0,0 +1,337 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackage = createPackage;
+exports.createPackageWithOptions = createPackageWithOptions;
+exports.createPackageFromFiles = createPackageFromFiles;
+exports.createPackageFromStreams = createPackageFromStreams;
+exports.statFile = statFile;
+exports.getRawHeader = getRawHeader;
+exports.listPackage = listPackage;
+exports.extractFile = extractFile;
+exports.extractAll = extractAll;
+exports.uncache = uncache;
+exports.uncacheAll = uncacheAll;
+const path = __importStar(require("path"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const wrapped_fs_1 = __importDefault(require("./wrapped-fs"));
+const filesystem_1 = require("./filesystem");
+const disk = __importStar(require("./disk"));
+const crawlfs_1 = require("./crawlfs");
+/**
+ * Whether a directory should be excluded from packing due to the `--unpack-dir" option.
+ *
+ * @param dirPath - directory path to check
+ * @param pattern - literal prefix [for backward compatibility] or glob pattern
+ * @param unpackDirs - Array of directory paths previously marked as unpacked
+ */
+function isUnpackedDir(dirPath, pattern, unpackDirs) {
+    if (dirPath.startsWith(pattern) || (0, minimatch_1.default)(dirPath, pattern)) {
+        if (!unpackDirs.includes(dirPath)) {
+            unpackDirs.push(dirPath);
+        }
+        return true;
+    }
+    else {
+        return unpackDirs.some((unpackDir) => dirPath.startsWith(unpackDir) && !path.relative(unpackDir, dirPath).startsWith('..'));
+    }
+}
+async function createPackage(src, dest) {
+    return createPackageWithOptions(src, dest, {});
+}
+async function createPackageWithOptions(src, dest, options) {
+    const globOptions = options.globOptions ? options.globOptions : {};
+    globOptions.dot = options.dot === undefined ? true : options.dot;
+    const pattern = src + (options.pattern ? options.pattern : '/**/*');
+    const [filenames, metadata] = await (0, crawlfs_1.crawl)(pattern, globOptions);
+    return createPackageFromFiles(src, dest, filenames, metadata, options);
+}
+/**
+ * Create an ASAR archive from a list of filenames.
+ *
+ * @param src - Base path. All files are relative to this.
+ * @param dest - Archive filename (& path).
+ * @param filenames - List of filenames relative to src.
+ * @param [metadata] - Object with filenames as keys and {type='directory|file|link', stat: fs.stat} as values. (Optional)
+ * @param [options] - Options passed to `createPackageWithOptions`.
+ */
+async function createPackageFromFiles(src, dest, filenames, metadata = {}, options = {}) {
+    src = path.normalize(src);
+    dest = path.normalize(dest);
+    filenames = filenames.map(function (filename) {
+        return path.normalize(filename);
+    });
+    const filesystem = new filesystem_1.Filesystem(src);
+    const files = [];
+    const links = [];
+    const unpackDirs = [];
+    let filenamesSorted = [];
+    if (options.ordering) {
+        const orderingFiles = (await wrapped_fs_1.default.readFile(options.ordering))
+            .toString()
+            .split('\n')
+            .map((line) => {
+            if (line.includes(':')) {
+                line = line.split(':').pop();
+            }
+            line = line.trim();
+            if (line.startsWith('/')) {
+                line = line.slice(1);
+            }
+            return line;
+        });
+        const ordering = [];
+        for (const file of orderingFiles) {
+            const pathComponents = file.split(path.sep);
+            let str = src;
+            for (const pathComponent of pathComponents) {
+                str = path.join(str, pathComponent);
+                ordering.push(str);
+            }
+        }
+        let missing = 0;
+        const total = filenames.length;
+        for (const file of ordering) {
+            if (!filenamesSorted.includes(file) && filenames.includes(file)) {
+                filenamesSorted.push(file);
+            }
+        }
+        for (const file of filenames) {
+            if (!filenamesSorted.includes(file)) {
+                filenamesSorted.push(file);
+                missing += 1;
+            }
+        }
+        console.log(`Ordering file has ${((total - missing) / total) * 100}% coverage.`);
+    }
+    else {
+        filenamesSorted = filenames;
+    }
+    const handleFile = async function (filename) {
+        if (!metadata[filename]) {
+            const fileType = await (0, crawlfs_1.determineFileType)(filename);
+            if (!fileType) {
+                throw new Error('Unknown file type for file: ' + filename);
+            }
+            metadata[filename] = fileType;
+        }
+        const file = metadata[filename];
+        const shouldUnpackPath = function (relativePath, unpack, unpackDir) {
+            let shouldUnpack = false;
+            if (unpack) {
+                shouldUnpack = (0, minimatch_1.default)(filename, unpack, { matchBase: true });
+            }
+            if (!shouldUnpack && unpackDir) {
+                shouldUnpack = isUnpackedDir(relativePath, unpackDir, unpackDirs);
+            }
+            return shouldUnpack;
+        };
+        let shouldUnpack;
+        switch (file.type) {
+            case 'directory':
+                shouldUnpack = shouldUnpackPath(path.relative(src, filename), undefined, options.unpackDir);
+                filesystem.insertDirectory(filename, shouldUnpack);
+                break;
+            case 'file':
+                shouldUnpack = shouldUnpackPath(path.relative(src, path.dirname(filename)), options.unpack, options.unpackDir);
+                files.push({ filename, unpack: shouldUnpack });
+                return filesystem.insertFile(filename, () => wrapped_fs_1.default.createReadStream(filename), shouldUnpack, file, options);
+            case 'link':
+                shouldUnpack = shouldUnpackPath(path.relative(src, filename), options.unpack, options.unpackDir);
+                links.push({ filename, unpack: shouldUnpack });
+                filesystem.insertLink(filename, shouldUnpack);
+                break;
+        }
+        return Promise.resolve();
+    };
+    const insertsDone = async function () {
+        await wrapped_fs_1.default.mkdirp(path.dirname(dest));
+        return disk.writeFilesystem(dest, filesystem, { files, links }, metadata);
+    };
+    const names = filenamesSorted.slice();
+    const next = async function (name) {
+        if (!name) {
+            return insertsDone();
+        }
+        await handleFile(name);
+        return next(names.shift());
+    };
+    return next(names.shift());
+}
+/**
+ * Create an ASAR archive from a list of streams.
+ *
+ * @param dest - Archive filename (& path).
+ * @param streams - List of streams to be piped in-memory into asar filesystem. Insertion order is preserved.
+ */
+async function createPackageFromStreams(dest, streams) {
+    // We use an ambiguous root `src` since we're piping directly from a stream and the `filePath` for the stream is already relative to the src/root
+    const src = '.';
+    const filesystem = new filesystem_1.Filesystem(src);
+    const files = [];
+    const links = [];
+    const handleFile = async function (stream) {
+        const { path: destinationPath, type } = stream;
+        const filename = path.normalize(destinationPath);
+        switch (type) {
+            case 'directory':
+                filesystem.insertDirectory(filename, stream.unpacked);
+                break;
+            case 'file':
+                files.push({
+                    filename,
+                    streamGenerator: stream.streamGenerator,
+                    link: undefined,
+                    mode: stream.stat.mode,
+                    unpack: stream.unpacked,
+                });
+                return filesystem.insertFile(filename, stream.streamGenerator, stream.unpacked, {
+                    type: 'file',
+                    stat: stream.stat,
+                });
+            case 'link':
+                links.push({
+                    filename,
+                    streamGenerator: stream.streamGenerator,
+                    link: stream.symlink,
+                    mode: stream.stat.mode,
+                    unpack: stream.unpacked,
+                });
+                filesystem.insertLink(filename, stream.unpacked, path.dirname(filename), stream.symlink, src);
+                break;
+        }
+        return Promise.resolve();
+    };
+    const insertsDone = async function () {
+        await wrapped_fs_1.default.mkdirp(path.dirname(dest));
+        return disk.streamFilesystem(dest, filesystem, { files, links });
+    };
+    const streamQueue = streams.slice();
+    const next = async function (stream) {
+        if (!stream) {
+            return insertsDone();
+        }
+        await handleFile(stream);
+        return next(streamQueue.shift());
+    };
+    return next(streamQueue.shift());
+}
+function statFile(archivePath, filename, followLinks = true) {
+    const filesystem = disk.readFilesystemSync(archivePath);
+    return filesystem.getFile(filename, followLinks);
+}
+function getRawHeader(archivePath) {
+    return disk.readArchiveHeaderSync(archivePath);
+}
+function listPackage(archivePath, options) {
+    return disk.readFilesystemSync(archivePath).listFiles(options);
+}
+function extractFile(archivePath, filename, followLinks = true) {
+    const filesystem = disk.readFilesystemSync(archivePath);
+    const fileInfo = filesystem.getFile(filename, followLinks);
+    if ('link' in fileInfo || 'files' in fileInfo) {
+        throw new Error('Expected to find file at: ' + filename + ' but found a directory or link');
+    }
+    return disk.readFileSync(filesystem, filename, fileInfo);
+}
+function extractAll(archivePath, dest) {
+    const filesystem = disk.readFilesystemSync(archivePath);
+    const filenames = filesystem.listFiles();
+    // under windows just extract links as regular files
+    const followLinks = process.platform === 'win32';
+    // create destination directory
+    wrapped_fs_1.default.mkdirpSync(dest);
+    const extractionErrors = [];
+    for (const fullPath of filenames) {
+        // Remove leading slash
+        const filename = fullPath.substr(1);
+        const destFilename = path.join(dest, filename);
+        const file = filesystem.getFile(filename, followLinks);
+        if (path.relative(dest, destFilename).startsWith('..')) {
+            throw new Error(`${fullPath}: file "${destFilename}" writes out of the package`);
+        }
+        if ('files' in file) {
+            // it's a directory, create it and continue with the next entry
+            wrapped_fs_1.default.mkdirpSync(destFilename);
+        }
+        else if ('link' in file) {
+            // it's a symlink, create a symlink
+            const linkSrcPath = path.dirname(path.join(dest, file.link));
+            const linkDestPath = path.dirname(destFilename);
+            const relativePath = path.relative(linkDestPath, linkSrcPath);
+            // try to delete output file, because we can't overwrite a link
+            try {
+                wrapped_fs_1.default.unlinkSync(destFilename);
+            }
+            catch (_a) { }
+            const linkTo = path.join(relativePath, path.basename(file.link));
+            if (path.relative(dest, linkSrcPath).startsWith('..')) {
+                throw new Error(`${fullPath}: file "${file.link}" links out of the package to "${linkSrcPath}"`);
+            }
+            wrapped_fs_1.default.symlinkSync(linkTo, destFilename);
+        }
+        else {
+            // it's a file, try to extract it
+            try {
+                const content = disk.readFileSync(filesystem, filename, file);
+                wrapped_fs_1.default.writeFileSync(destFilename, content);
+                if (file.executable) {
+                    wrapped_fs_1.default.chmodSync(destFilename, '755');
+                }
+            }
+            catch (e) {
+                extractionErrors.push(e);
+            }
+        }
+    }
+    if (extractionErrors.length) {
+        throw new Error('Unable to extract some files:\n\n' +
+            extractionErrors.map((error) => error.stack).join('\n\n'));
+    }
+}
+function uncache(archivePath) {
+    return disk.uncacheFilesystem(archivePath);
+}
+function uncacheAll() {
+    disk.uncacheAll();
+}
+// Export everything in default, too
+exports.default = {
+    createPackage,
+    createPackageWithOptions,
+    createPackageFromFiles,
+    createPackageFromStreams,
+    statFile,
+    getRawHeader,
+    listPackage,
+    extractFile,
+    extractAll,
+    uncache,
+    uncacheAll,
+};
+//# sourceMappingURL=asar.js.map
--- a/node_modules/@electron/asar/lib/asar.js.map
+++ b/node_modules/@electron/asar/lib/asar.js.map
--- a/node_modules/@electron/asar/lib/crawlfs.d.ts
+++ b/node_modules/@electron/asar/lib/crawlfs.d.ts
@ -0,0 +1,12 @@
+import { Stats } from 'fs';
+import { IOptions } from './types/glob';
+export type CrawledFileType = {
+    type: 'file' | 'directory' | 'link';
+    stat: Pick<Stats, 'mode' | 'size'>;
+    transformed?: {
+        path: string;
+        stat: Stats;
+    };
+};
+export declare function determineFileType(filename: string): Promise<CrawledFileType | null>;
+export declare function crawl(dir: string, options: IOptions): Promise<readonly [string[], Record<string, CrawledFileType>]>;
--- a/node_modules/@electron/asar/lib/crawlfs.js
+++ b/node_modules/@electron/asar/lib/crawlfs.js
@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineFileType = determineFileType;
+exports.crawl = crawl;
+const util_1 = require("util");
+const glob_1 = require("glob");
+const wrapped_fs_1 = __importDefault(require("./wrapped-fs"));
+const path = __importStar(require("path"));
+const glob = (0, util_1.promisify)(glob_1.glob);
+async function determineFileType(filename) {
+    const stat = await wrapped_fs_1.default.lstat(filename);
+    if (stat.isFile()) {
+        return { type: 'file', stat };
+    }
+    else if (stat.isDirectory()) {
+        return { type: 'directory', stat };
+    }
+    else if (stat.isSymbolicLink()) {
+        return { type: 'link', stat };
+    }
+    return null;
+}
+async function crawl(dir, options) {
+    const metadata = {};
+    const crawled = await glob(dir, options);
+    const results = await Promise.all(crawled.map(async (filename) => [filename, await determineFileType(filename)]));
+    const links = [];
+    const filenames = results
+        .map(([filename, type]) => {
+        if (type) {
+            metadata[filename] = type;
+            if (type.type === 'link')
+                links.push(filename);
+        }
+        return filename;
+    })
+        .filter((filename) => {
+        // Newer glob can return files inside symlinked directories, to avoid
+        // those appearing in archives we need to manually exclude theme here
+        const exactLinkIndex = links.findIndex((link) => filename === link);
+        return links.every((link, index) => {
+            if (index === exactLinkIndex) {
+                return true;
+            }
+            const isFileWithinSymlinkDir = filename.startsWith(link);
+            // symlink may point outside the directory: https://github.com/electron/asar/issues/303
+            const relativePath = path.relative(link, path.dirname(filename));
+            return !isFileWithinSymlinkDir || relativePath.startsWith('..');
+        });
+    });
+    return [filenames, metadata];
+}
+//# sourceMappingURL=crawlfs.js.map
--- a/node_modules/@electron/asar/lib/crawlfs.js.map
+++ b/node_modules/@electron/asar/lib/crawlfs.js.map
@ -0,0 +1 @@
+{"version":3,"file":"crawlfs.js","sourceRoot":"","sources":["../src/crawlfs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,8CAUC;AAED,sBA8BC;AA7DD,+BAAiC;AACjC,+BAAqC;AAErC,8DAA8B;AAE9B,2CAA6B;AAG7B,MAAM,IAAI,GAAG,IAAA,gBAAS,EAAC,WAAK,CAAC,CAAC;AAWvB,KAAK,UAAU,iBAAiB,CAAC,QAAgB;IACtD,MAAM,IAAI,GAAG,MAAM,oBAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QAClB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAChC,CAAC;SAAM,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;IACrC,CAAC;SAAM,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QACjC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAChC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAEM,KAAK,UAAU,KAAK,CAAC,GAAW,EAAE,OAAiB;IACxD,MAAM,QAAQ,GAAoC,EAAE,CAAC;IACrD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAU,CAAC,CACxF,CAAC;IACF,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,SAAS,GAAG,OAAO;SACtB,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,EAAE;QACxB,IAAI,IAAI,EAAE,CAAC;YACT,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;YAC1B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE;QACnB,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,cAAc,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC;QACpE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,KAAK,KAAK,cAAc,EAAE,CAAC;gBAC7B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,sBAAsB,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACzD,uFAAuF;YACvF,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YACjE,OAAO,CAAC,sBAAsB,IAAI,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACL,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAU,CAAC;AACxC,CAAC"}
--- a/node_modules/@electron/asar/lib/disk.d.ts
+++ b/node_modules/@electron/asar/lib/disk.d.ts
@ -0,0 +1,44 @@
+import { Filesystem, FilesystemFileEntry } from './filesystem';
+import { CrawledFileType } from './crawlfs';
+import { Stats } from 'fs';
+export type InputMetadata = {
+    [property: string]: CrawledFileType;
+};
+export type BasicFilesArray = {
+    filename: string;
+    unpack: boolean;
+}[];
+export type BasicStreamArray = {
+    filename: string;
+    streamGenerator: () => NodeJS.ReadableStream;
+    mode: Stats['mode'];
+    unpack: boolean;
+    link: string | undefined;
+}[];
+export type FilesystemFilesAndLinks<T extends BasicFilesArray | BasicStreamArray> = {
+    files: T;
+    links: T;
+};
+export declare function writeFilesystem(dest: string, filesystem: Filesystem, lists: FilesystemFilesAndLinks<BasicFilesArray>, metadata: InputMetadata): Promise<NodeJS.WritableStream>;
+export declare function streamFilesystem(dest: string, filesystem: Filesystem, lists: FilesystemFilesAndLinks<BasicStreamArray>): Promise<import("fs").WriteStream>;
+export interface FileRecord extends FilesystemFileEntry {
+    integrity: {
+        hash: string;
+        algorithm: 'SHA256';
+        blocks: string[];
+        blockSize: number;
+    };
+}
+export type DirectoryRecord = {
+    files: Record<string, DirectoryRecord | FileRecord>;
+};
+export type ArchiveHeader = {
+    header: DirectoryRecord;
+    headerString: string;
+    headerSize: number;
+};
+export declare function readArchiveHeaderSync(archivePath: string): ArchiveHeader;
+export declare function readFilesystemSync(archivePath: string): Filesystem;
+export declare function uncacheFilesystem(archivePath: string): boolean;
+export declare function uncacheAll(): void;
+export declare function readFileSync(filesystem: Filesystem, filename: string, info: FilesystemFileEntry): Buffer;
--- a/node_modules/@electron/asar/lib/disk.js
+++ b/node_modules/@electron/asar/lib/disk.js
@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFilesystem = writeFilesystem;
+exports.streamFilesystem = streamFilesystem;
+exports.readArchiveHeaderSync = readArchiveHeaderSync;
+exports.readFilesystemSync = readFilesystemSync;
+exports.uncacheFilesystem = uncacheFilesystem;
+exports.uncacheAll = uncacheAll;
+exports.readFileSync = readFileSync;
+const path = __importStar(require("path"));
+const wrapped_fs_1 = __importDefault(require("./wrapped-fs"));
+const pickle_1 = require("./pickle");
+const filesystem_1 = require("./filesystem");
+const util_1 = require("util");
+const stream = __importStar(require("stream"));
+const pipeline = (0, util_1.promisify)(stream.pipeline);
+let filesystemCache = Object.create(null);
+async function copyFile(dest, src, filename) {
+    const srcFile = path.join(src, filename);
+    const targetFile = path.join(dest, filename);
+    const [content, stats] = await Promise.all([
+        wrapped_fs_1.default.readFile(srcFile),
+        wrapped_fs_1.default.stat(srcFile),
+        wrapped_fs_1.default.mkdirp(path.dirname(targetFile)),
+    ]);
+    return wrapped_fs_1.default.writeFile(targetFile, content, { mode: stats.mode });
+}
+async function streamTransformedFile(stream, outStream) {
+    return new Promise((resolve, reject) => {
+        stream.pipe(outStream, { end: false });
+        stream.on('error', reject);
+        stream.on('end', () => resolve());
+    });
+}
+const writeFileListToStream = async function (dest, filesystem, out, lists, metadata) {
+    const { files, links } = lists;
+    for (const file of files) {
+        if (file.unpack) {
+            // the file should not be packed into archive
+            const filename = path.relative(filesystem.getRootPath(), file.filename);
+            await copyFile(`${dest}.unpacked`, filesystem.getRootPath(), filename);
+        }
+        else {
+            const transformed = metadata[file.filename].transformed;
+            const stream = wrapped_fs_1.default.createReadStream(transformed ? transformed.path : file.filename);
+            await streamTransformedFile(stream, out);
+        }
+    }
+    for (const file of links.filter((f) => f.unpack)) {
+        // the symlink needs to be recreated outside in .unpacked
+        const filename = path.relative(filesystem.getRootPath(), file.filename);
+        const link = await wrapped_fs_1.default.readlink(file.filename);
+        await createSymlink(dest, filename, link);
+    }
+    return out.end();
+};
+async function writeFilesystem(dest, filesystem, lists, metadata) {
+    const out = await createFilesystemWriteStream(filesystem, dest);
+    return writeFileListToStream(dest, filesystem, out, lists, metadata);
+}
+async function streamFilesystem(dest, filesystem, lists) {
+    var _a, e_1, _b, _c;
+    const out = await createFilesystemWriteStream(filesystem, dest);
+    const { files, links } = lists;
+    try {
+        for (var _d = true, files_1 = __asyncValues(files), files_1_1; files_1_1 = await files_1.next(), _a = files_1_1.done, !_a; _d = true) {
+            _c = files_1_1.value;
+            _d = false;
+            const file = _c;
+            // the file should not be packed into archive
+            if (file.unpack) {
+                const targetFile = path.join(`${dest}.unpacked`, file.filename);
+                await wrapped_fs_1.default.mkdirp(path.dirname(targetFile));
+                const writeStream = wrapped_fs_1.default.createWriteStream(targetFile, { mode: file.mode });
+                await pipeline(file.streamGenerator(), writeStream);
+            }
+            else {
+                await streamTransformedFile(file.streamGenerator(), out);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = files_1.return)) await _b.call(files_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    for (const file of links.filter((f) => f.unpack && f.link)) {
+        // the symlink needs to be recreated outside in .unpacked
+        await createSymlink(dest, file.filename, file.link);
+    }
+    return out.end();
+}
+function readArchiveHeaderSync(archivePath) {
+    const fd = wrapped_fs_1.default.openSync(archivePath, 'r');
+    let size;
+    let headerBuf;
+    try {
+        const sizeBuf = Buffer.alloc(8);
+        if (wrapped_fs_1.default.readSync(fd, sizeBuf, 0, 8, null) !== 8) {
+            throw new Error('Unable to read header size');
+        }
+        const sizePickle = pickle_1.Pickle.createFromBuffer(sizeBuf);
+        size = sizePickle.createIterator().readUInt32();
+        headerBuf = Buffer.alloc(size);
+        if (wrapped_fs_1.default.readSync(fd, headerBuf, 0, size, null) !== size) {
+            throw new Error('Unable to read header');
+        }
+    }
+    finally {
+        wrapped_fs_1.default.closeSync(fd);
+    }
+    const headerPickle = pickle_1.Pickle.createFromBuffer(headerBuf);
+    const header = headerPickle.createIterator().readString();
+    return { headerString: header, header: JSON.parse(header), headerSize: size };
+}
+function readFilesystemSync(archivePath) {
+    if (!filesystemCache[archivePath]) {
+        const header = readArchiveHeaderSync(archivePath);
+        const filesystem = new filesystem_1.Filesystem(archivePath);
+        filesystem.setHeader(header.header, header.headerSize);
+        filesystemCache[archivePath] = filesystem;
+    }
+    return filesystemCache[archivePath];
+}
+function uncacheFilesystem(archivePath) {
+    if (filesystemCache[archivePath]) {
+        filesystemCache[archivePath] = undefined;
+        return true;
+    }
+    return false;
+}
+function uncacheAll() {
+    filesystemCache = {};
+}
+function readFileSync(filesystem, filename, info) {
+    let buffer = Buffer.alloc(info.size);
+    if (info.size <= 0) {
+        return buffer;
+    }
+    if (info.unpacked) {
+        // it's an unpacked file, copy it.
+        buffer = wrapped_fs_1.default.readFileSync(path.join(`${filesystem.getRootPath()}.unpacked`, filename));
+    }
+    else {
+        // Node throws an exception when reading 0 bytes into a 0-size buffer,
+        // so we short-circuit the read in this case.
+        const fd = wrapped_fs_1.default.openSync(filesystem.getRootPath(), 'r');
+        try {
+            const offset = 8 + filesystem.getHeaderSize() + parseInt(info.offset);
+            wrapped_fs_1.default.readSync(fd, buffer, 0, info.size, offset);
+        }
+        finally {
+            wrapped_fs_1.default.closeSync(fd);
+        }
+    }
+    return buffer;
+}
+async function createFilesystemWriteStream(filesystem, dest) {
+    const headerPickle = pickle_1.Pickle.createEmpty();
+    headerPickle.writeString(JSON.stringify(filesystem.getHeader()));
+    const headerBuf = headerPickle.toBuffer();
+    const sizePickle = pickle_1.Pickle.createEmpty();
+    sizePickle.writeUInt32(headerBuf.length);
+    const sizeBuf = sizePickle.toBuffer();
+    const out = wrapped_fs_1.default.createWriteStream(dest);
+    await new Promise((resolve, reject) => {
+        out.on('error', reject);
+        out.write(sizeBuf);
+        return out.write(headerBuf, () => resolve());
+    });
+    return out;
+}
+async function createSymlink(dest, filepath, link) {
+    // if symlink is within subdirectories, then we need to recreate dir structure
+    await wrapped_fs_1.default.mkdirp(path.join(`${dest}.unpacked`, path.dirname(filepath)));
+    // create symlink within unpacked dir
+    await wrapped_fs_1.default.symlink(link, path.join(`${dest}.unpacked`, filepath)).catch(async (error) => {
+        if (error.code === 'EPERM' && error.syscall === 'symlink') {
+            throw new Error('Could not create symlinks for unpacked assets. On Windows, consider activating Developer Mode to allow non-admin users to create symlinks by following the instructions at https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development.');
+        }
+        throw error;
+    });
+}
+//# sourceMappingURL=disk.js.map
--- a/node_modules/@electron/asar/lib/disk.js.map
+++ b/node_modules/@electron/asar/lib/disk.js.map
--- a/node_modules/@electron/asar/lib/filesystem.d.ts
+++ b/node_modules/@electron/asar/lib/filesystem.d.ts
@ -0,0 +1,44 @@
+import { FileIntegrity } from './integrity';
+import { CrawledFileType } from './crawlfs';
+export type EntryMetadata = {
+    unpacked?: boolean;
+};
+export type FilesystemDirectoryEntry = {
+    files: Record<string, FilesystemEntry>;
+} & EntryMetadata;
+export type FilesystemFileEntry = {
+    unpacked: boolean;
+    executable: boolean;
+    offset: string;
+    size: number;
+    integrity: FileIntegrity;
+} & EntryMetadata;
+export type FilesystemLinkEntry = {
+    link: string;
+} & EntryMetadata;
+export type FilesystemEntry = FilesystemDirectoryEntry | FilesystemFileEntry | FilesystemLinkEntry;
+export declare class Filesystem {
+    private src;
+    private header;
+    private headerSize;
+    private offset;
+    constructor(src: string);
+    getRootPath(): string;
+    getHeader(): FilesystemEntry;
+    getHeaderSize(): number;
+    setHeader(header: FilesystemEntry, headerSize: number): void;
+    searchNodeFromDirectory(p: string): FilesystemEntry;
+    searchNodeFromPath(p: string): FilesystemEntry;
+    insertDirectory(p: string, shouldUnpack: boolean): Record<string, FilesystemEntry>;
+    insertFile(p: string, streamGenerator: () => NodeJS.ReadableStream, shouldUnpack: boolean, file: CrawledFileType, options?: {
+        transform?: (filePath: string) => NodeJS.ReadWriteStream | void;
+    }): Promise<void>;
+    insertLink(p: string, shouldUnpack: boolean, parentPath?: string, symlink?: string, // /var/tmp => /private/var
+    src?: string): string;
+    private resolveLink;
+    listFiles(options?: {
+        isPack: boolean;
+    }): string[];
+    getNode(p: string, followLinks?: boolean): FilesystemEntry;
+    getFile(p: string, followLinks?: boolean): FilesystemEntry;
+}
--- a/node_modules/@electron/asar/lib/filesystem.js
+++ b/node_modules/@electron/asar/lib/filesystem.js
@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filesystem = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const stream = __importStar(require("stream"));
+const integrity_1 = require("./integrity");
+const wrapped_fs_1 = __importDefault(require("./wrapped-fs"));
+const UINT32_MAX = 2 ** 32 - 1;
+const pipeline = (0, util_1.promisify)(stream.pipeline);
+class Filesystem {
+    constructor(src) {
+        this.src = path.resolve(src);
+        this.header = { files: Object.create(null) };
+        this.headerSize = 0;
+        this.offset = BigInt(0);
+    }
+    getRootPath() {
+        return this.src;
+    }
+    getHeader() {
+        return this.header;
+    }
+    getHeaderSize() {
+        return this.headerSize;
+    }
+    setHeader(header, headerSize) {
+        this.header = header;
+        this.headerSize = headerSize;
+    }
+    searchNodeFromDirectory(p) {
+        let json = this.header;
+        const dirs = p.split(path.sep);
+        for (const dir of dirs) {
+            if (dir !== '.') {
+                if ('files' in json) {
+                    if (!json.files[dir]) {
+                        json.files[dir] = { files: Object.create(null) };
+                    }
+                    json = json.files[dir];
+                }
+                else {
+                    throw new Error('Unexpected directory state while traversing: ' + p);
+                }
+            }
+        }
+        return json;
+    }
+    searchNodeFromPath(p) {
+        p = path.relative(this.src, p);
+        if (!p) {
+            return this.header;
+        }
+        const name = path.basename(p);
+        const node = this.searchNodeFromDirectory(path.dirname(p));
+        if (!node.files) {
+            node.files = Object.create(null);
+        }
+        if (!node.files[name]) {
+            node.files[name] = Object.create(null);
+        }
+        return node.files[name];
+    }
+    insertDirectory(p, shouldUnpack) {
+        const node = this.searchNodeFromPath(p);
+        if (shouldUnpack) {
+            node.unpacked = shouldUnpack;
+        }
+        node.files = node.files || Object.create(null);
+        return node.files;
+    }
+    async insertFile(p, streamGenerator, shouldUnpack, file, options = {}) {
+        const dirNode = this.searchNodeFromPath(path.dirname(p));
+        const node = this.searchNodeFromPath(p);
+        if (shouldUnpack || dirNode.unpacked) {
+            node.size = file.stat.size;
+            node.unpacked = true;
+            node.integrity = await (0, integrity_1.getFileIntegrity)(streamGenerator());
+            return Promise.resolve();
+        }
+        let size;
+        const transformed = options.transform && options.transform(p);
+        if (transformed) {
+            const tmpdir = await wrapped_fs_1.default.mkdtemp(path.join(os.tmpdir(), 'asar-'));
+            const tmpfile = path.join(tmpdir, path.basename(p));
+            const out = wrapped_fs_1.default.createWriteStream(tmpfile);
+            await pipeline(streamGenerator(), transformed, out);
+            file.transformed = {
+                path: tmpfile,
+                stat: await wrapped_fs_1.default.lstat(tmpfile),
+            };
+            size = file.transformed.stat.size;
+        }
+        else {
+            size = file.stat.size;
+        }
+        // JavaScript cannot precisely present integers >= UINT32_MAX.
+        if (size > UINT32_MAX) {
+            throw new Error(`${p}: file size can not be larger than 4.2GB`);
+        }
+        node.size = size;
+        node.offset = this.offset.toString();
+        node.integrity = await (0, integrity_1.getFileIntegrity)(streamGenerator());
+        if (process.platform !== 'win32' && file.stat.mode & 0o100) {
+            node.executable = true;
+        }
+        this.offset += BigInt(size);
+    }
+    insertLink(p, shouldUnpack, parentPath = wrapped_fs_1.default.realpathSync(path.dirname(p)), symlink = wrapped_fs_1.default.readlinkSync(p), // /var/tmp => /private/var
+    src = wrapped_fs_1.default.realpathSync(this.src)) {
+        const link = this.resolveLink(src, parentPath, symlink);
+        if (link.startsWith('..')) {
+            throw new Error(`${p}: file "${link}" links out of the package`);
+        }
+        const node = this.searchNodeFromPath(p);
+        const dirNode = this.searchNodeFromPath(path.dirname(p));
+        if (shouldUnpack || dirNode.unpacked) {
+            node.unpacked = true;
+        }
+        node.link = link;
+        return link;
+    }
+    resolveLink(src, parentPath, symlink) {
+        const target = path.join(parentPath, symlink);
+        const link = path.relative(src, target);
+        return link;
+    }
+    listFiles(options) {
+        const files = [];
+        const fillFilesFromMetadata = function (basePath, metadata) {
+            if (!('files' in metadata)) {
+                return;
+            }
+            for (const [childPath, childMetadata] of Object.entries(metadata.files)) {
+                const fullPath = path.join(basePath, childPath);
+                const packState = 'unpacked' in childMetadata && childMetadata.unpacked ? 'unpack' : 'pack  ';
+                files.push(options && options.isPack ? `${packState} : ${fullPath}` : fullPath);
+                fillFilesFromMetadata(fullPath, childMetadata);
+            }
+        };
+        fillFilesFromMetadata('/', this.header);
+        return files;
+    }
+    getNode(p, followLinks = true) {
+        const node = this.searchNodeFromDirectory(path.dirname(p));
+        const name = path.basename(p);
+        if ('link' in node && followLinks) {
+            return this.getNode(path.join(node.link, name));
+        }
+        if (name) {
+            return node.files[name];
+        }
+        else {
+            return node;
+        }
+    }
+    getFile(p, followLinks = true) {
+        const info = this.getNode(p, followLinks);
+        if (!info) {
+            throw new Error(`"${p}" was not found in this archive`);
+        }
+        // if followLinks is false we don't resolve symlinks
+        if ('link' in info && followLinks) {
+            return this.getFile(info.link, followLinks);
+        }
+        else {
+            return info;
+        }
+    }
+}
+exports.Filesystem = Filesystem;
+//# sourceMappingURL=filesystem.js.map
--- a/node_modules/@electron/asar/lib/filesystem.js.map
+++ b/node_modules/@electron/asar/lib/filesystem.js.map
--- a/node_modules/@electron/asar/lib/integrity.d.ts
+++ b/node_modules/@electron/asar/lib/integrity.d.ts
@ -0,0 +1,7 @@
+export type FileIntegrity = {
+    algorithm: 'SHA256';
+    hash: string;
+    blockSize: number;
+    blocks: string[];
+};
+export declare function getFileIntegrity(inputFileStream: NodeJS.ReadableStream): Promise<FileIntegrity>;
--- a/node_modules/@electron/asar/lib/integrity.js
+++ b/node_modules/@electron/asar/lib/integrity.js
@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileIntegrity = getFileIntegrity;
+const crypto = __importStar(require("crypto"));
+const stream = __importStar(require("stream"));
+const util_1 = require("util");
+const ALGORITHM = 'SHA256';
+// 4MB default block size
+const BLOCK_SIZE = 4 * 1024 * 1024;
+const pipeline = (0, util_1.promisify)(stream.pipeline);
+function hashBlock(block) {
+    return crypto.createHash(ALGORITHM).update(block).digest('hex');
+}
+async function getFileIntegrity(inputFileStream) {
+    const fileHash = crypto.createHash(ALGORITHM);
+    const blockHashes = [];
+    let currentBlockSize = 0;
+    let currentBlock = [];
+    await pipeline(inputFileStream, new stream.PassThrough({
+        decodeStrings: false,
+        transform(_chunk, encoding, callback) {
+            fileHash.update(_chunk);
+            function handleChunk(chunk) {
+                const diffToSlice = Math.min(BLOCK_SIZE - currentBlockSize, chunk.byteLength);
+                currentBlockSize += diffToSlice;
+                currentBlock.push(chunk.slice(0, diffToSlice));
+                if (currentBlockSize === BLOCK_SIZE) {
+                    blockHashes.push(hashBlock(Buffer.concat(currentBlock)));
+                    currentBlock = [];
+                    currentBlockSize = 0;
+                }
+                if (diffToSlice < chunk.byteLength) {
+                    handleChunk(chunk.slice(diffToSlice));
+                }
+            }
+            handleChunk(_chunk);
+            callback();
+        },
+        flush(callback) {
+            blockHashes.push(hashBlock(Buffer.concat(currentBlock)));
+            currentBlock = [];
+            callback();
+        },
+    }));
+    return {
+        algorithm: ALGORITHM,
+        hash: fileHash.digest('hex'),
+        blockSize: BLOCK_SIZE,
+        blocks: blockHashes,
+    };
+}
+//# sourceMappingURL=integrity.js.map
--- a/node_modules/@electron/asar/lib/integrity.js.map
+++ b/node_modules/@electron/asar/lib/integrity.js.map
@ -0,0 +1 @@
+{"version":3,"file":"integrity.js","sourceRoot":"","sources":["../src/integrity.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,4CA8CC;AApED,+CAAiC;AAEjC,+CAAiC;AACjC,+BAAiC;AAEjC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAC3B,yBAAyB;AACzB,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAEnC,MAAM,QAAQ,GAAG,IAAA,gBAAS,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAE5C,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC;AASM,KAAK,UAAU,gBAAgB,CACpC,eAAsC;IAEtC,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAE9C,MAAM,WAAW,GAAa,EAAE,CAAC;IACjC,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,IAAI,YAAY,GAAa,EAAE,CAAC;IAEhC,MAAM,QAAQ,CACZ,eAAe,EACf,IAAI,MAAM,CAAC,WAAW,CAAC;QACrB,aAAa,EAAE,KAAK;QACpB,SAAS,CAAC,MAAc,EAAE,QAAQ,EAAE,QAAQ;YAC1C,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAExB,SAAS,WAAW,CAAC,KAAa;gBAChC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;gBAC9E,gBAAgB,IAAI,WAAW,CAAC;gBAChC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;gBAC/C,IAAI,gBAAgB,KAAK,UAAU,EAAE,CAAC;oBACpC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBACzD,YAAY,GAAG,EAAE,CAAC;oBAClB,gBAAgB,GAAG,CAAC,CAAC;gBACvB,CAAC;gBACD,IAAI,WAAW,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;oBACnC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YACD,WAAW,CAAC,MAAM,CAAC,CAAC;YACpB,QAAQ,EAAE,CAAC;QACb,CAAC;QACD,KAAK,CAAC,QAAQ;YACZ,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACzD,YAAY,GAAG,EAAE,CAAC;YAClB,QAAQ,EAAE,CAAC;QACb,CAAC;KACF,CAAC,CACH,CAAC;IAEF,OAAO;QACL,SAAS,EAAE,SAAS;QACpB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;QAC5B,SAAS,EAAE,UAAU;QACrB,MAAM,EAAE,WAAW;KACpB,CAAC;AACJ,CAAC"}
--- a/node_modules/@electron/asar/lib/pickle.d.ts
+++ b/node_modules/@electron/asar/lib/pickle.d.ts
@ -0,0 +1,46 @@
+declare class PickleIterator {
+    private payload;
+    private payloadOffset;
+    private readIndex;
+    private endIndex;
+    constructor(pickle: Pickle);
+    readBool(): boolean;
+    readInt(): number;
+    readUInt32(): number;
+    readInt64(): bigint;
+    readUInt64(): bigint;
+    readFloat(): number;
+    readDouble(): number;
+    readString(): string;
+    readBytes(length: number): Buffer;
+    readBytes<R, F extends (...args: any[]) => R>(length: number, method: F): R;
+    getReadPayloadOffsetAndAdvance(length: number): number;
+    advance(size: number): void;
+}
+export declare class Pickle {
+    private header;
+    private headerSize;
+    private capacityAfterHeader;
+    private writeOffset;
+    private constructor();
+    static createEmpty(): Pickle;
+    static createFromBuffer(buffer: Buffer): Pickle;
+    getHeader(): Buffer;
+    getHeaderSize(): number;
+    createIterator(): PickleIterator;
+    toBuffer(): Buffer;
+    writeBool(value: boolean): boolean;
+    writeInt(value: number): boolean;
+    writeUInt32(value: number): boolean;
+    writeInt64(value: number): boolean;
+    writeUInt64(value: number): boolean;
+    writeFloat(value: number): boolean;
+    writeDouble(value: number): boolean;
+    writeString(value: string): boolean;
+    setPayloadSize(payloadSize: number): number;
+    getPayloadSize(): number;
+    writeBytes(data: string, length: number, method?: undefined): boolean;
+    writeBytes(data: number | BigInt, length: number, method: Function): boolean;
+    resize(newCapacity: number): void;
+}
+export {};
--- a/node_modules/@electron/asar/lib/pickle.js
+++ b/node_modules/@electron/asar/lib/pickle.js
@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pickle = void 0;
+// sizeof(T).
+const SIZE_INT32 = 4;
+const SIZE_UINT32 = 4;
+const SIZE_INT64 = 8;
+const SIZE_UINT64 = 8;
+const SIZE_FLOAT = 4;
+const SIZE_DOUBLE = 8;
+// The allocation granularity of the payload.
+const PAYLOAD_UNIT = 64;
+// Largest JS number.
+const CAPACITY_READ_ONLY = 9007199254740992;
+// Aligns 'i' by rounding it up to the next multiple of 'alignment'.
+const alignInt = function (i, alignment) {
+    return i + ((alignment - (i % alignment)) % alignment);
+};
+// PickleIterator reads data from a Pickle. The Pickle object must remain valid
+// while the PickleIterator object is in use.
+class PickleIterator {
+    constructor(pickle) {
+        this.payload = pickle.getHeader();
+        this.payloadOffset = pickle.getHeaderSize();
+        this.readIndex = 0;
+        this.endIndex = pickle.getPayloadSize();
+    }
+    readBool() {
+        return this.readInt() !== 0;
+    }
+    readInt() {
+        return this.readBytes(SIZE_INT32, Buffer.prototype.readInt32LE);
+    }
+    readUInt32() {
+        return this.readBytes(SIZE_UINT32, Buffer.prototype.readUInt32LE);
+    }
+    readInt64() {
+        return this.readBytes(SIZE_INT64, Buffer.prototype.readBigInt64LE);
+    }
+    readUInt64() {
+        return this.readBytes(SIZE_UINT64, Buffer.prototype.readBigUInt64LE);
+    }
+    readFloat() {
+        return this.readBytes(SIZE_FLOAT, Buffer.prototype.readFloatLE);
+    }
+    readDouble() {
+        return this.readBytes(SIZE_DOUBLE, Buffer.prototype.readDoubleLE);
+    }
+    readString() {
+        return this.readBytes(this.readInt()).toString();
+    }
+    readBytes(length, method) {
+        const readPayloadOffset = this.getReadPayloadOffsetAndAdvance(length);
+        if (method != null) {
+            return method.call(this.payload, readPayloadOffset, length);
+        }
+        else {
+            return this.payload.slice(readPayloadOffset, readPayloadOffset + length);
+        }
+    }
+    getReadPayloadOffsetAndAdvance(length) {
+        if (length > this.endIndex - this.readIndex) {
+            this.readIndex = this.endIndex;
+            throw new Error('Failed to read data with length of ' + length);
+        }
+        const readPayloadOffset = this.payloadOffset + this.readIndex;
+        this.advance(length);
+        return readPayloadOffset;
+    }
+    advance(size) {
+        const alignedSize = alignInt(size, SIZE_UINT32);
+        if (this.endIndex - this.readIndex < alignedSize) {
+            this.readIndex = this.endIndex;
+        }
+        else {
+            this.readIndex += alignedSize;
+        }
+    }
+}
+// This class provides facilities for basic binary value packing and unpacking.
+//
+// The Pickle class supports appending primitive values (ints, strings, etc.)
+// to a pickle instance.  The Pickle instance grows its internal memory buffer
+// dynamically to hold the sequence of primitive values.   The internal memory
+// buffer is exposed as the "data" of the Pickle.  This "data" can be passed
+// to a Pickle object to initialize it for reading.
+//
+// When reading from a Pickle object, it is important for the consumer to know
+// what value types to read and in what order to read them as the Pickle does
+// not keep track of the type of data written to it.
+//
+// The Pickle's data has a header which contains the size of the Pickle's
+// payload.  It can optionally support additional space in the header.  That
+// space is controlled by the header_size parameter passed to the Pickle
+// constructor.
+class Pickle {
+    constructor(buffer) {
+        if (buffer) {
+            this.header = buffer;
+            this.headerSize = buffer.length - this.getPayloadSize();
+            this.capacityAfterHeader = CAPACITY_READ_ONLY;
+            this.writeOffset = 0;
+            if (this.headerSize > buffer.length) {
+                this.headerSize = 0;
+            }
+            if (this.headerSize !== alignInt(this.headerSize, SIZE_UINT32)) {
+                this.headerSize = 0;
+            }
+            if (this.headerSize === 0) {
+                this.header = Buffer.alloc(0);
+            }
+        }
+        else {
+            this.header = Buffer.alloc(0);
+            this.headerSize = SIZE_UINT32;
+            this.capacityAfterHeader = 0;
+            this.writeOffset = 0;
+            this.resize(PAYLOAD_UNIT);
+            this.setPayloadSize(0);
+        }
+    }
+    static createEmpty() {
+        return new Pickle();
+    }
+    static createFromBuffer(buffer) {
+        return new Pickle(buffer);
+    }
+    getHeader() {
+        return this.header;
+    }
+    getHeaderSize() {
+        return this.headerSize;
+    }
+    createIterator() {
+        return new PickleIterator(this);
+    }
+    toBuffer() {
+        return this.header.slice(0, this.headerSize + this.getPayloadSize());
+    }
+    writeBool(value) {
+        return this.writeInt(value ? 1 : 0);
+    }
+    writeInt(value) {
+        return this.writeBytes(value, SIZE_INT32, Buffer.prototype.writeInt32LE);
+    }
+    writeUInt32(value) {
+        return this.writeBytes(value, SIZE_UINT32, Buffer.prototype.writeUInt32LE);
+    }
+    writeInt64(value) {
+        return this.writeBytes(BigInt(value), SIZE_INT64, Buffer.prototype.writeBigInt64LE);
+    }
+    writeUInt64(value) {
+        return this.writeBytes(BigInt(value), SIZE_UINT64, Buffer.prototype.writeBigUInt64LE);
+    }
+    writeFloat(value) {
+        return this.writeBytes(value, SIZE_FLOAT, Buffer.prototype.writeFloatLE);
+    }
+    writeDouble(value) {
+        return this.writeBytes(value, SIZE_DOUBLE, Buffer.prototype.writeDoubleLE);
+    }
+    writeString(value) {
+        const length = Buffer.byteLength(value, 'utf8');
+        if (!this.writeInt(length)) {
+            return false;
+        }
+        return this.writeBytes(value, length);
+    }
+    setPayloadSize(payloadSize) {
+        return this.header.writeUInt32LE(payloadSize, 0);
+    }
+    getPayloadSize() {
+        return this.header.readUInt32LE(0);
+    }
+    writeBytes(data, length, method) {
+        const dataLength = alignInt(length, SIZE_UINT32);
+        const newSize = this.writeOffset + dataLength;
+        if (newSize > this.capacityAfterHeader) {
+            this.resize(Math.max(this.capacityAfterHeader * 2, newSize));
+        }
+        if (method) {
+            method.call(this.header, data, this.headerSize + this.writeOffset);
+        }
+        else {
+            this.header.write(data, this.headerSize + this.writeOffset, length);
+        }
+        const endOffset = this.headerSize + this.writeOffset + length;
+        this.header.fill(0, endOffset, endOffset + dataLength - length);
+        this.setPayloadSize(newSize);
+        this.writeOffset = newSize;
+        return true;
+    }
+    resize(newCapacity) {
+        newCapacity = alignInt(newCapacity, PAYLOAD_UNIT);
+        this.header = Buffer.concat([this.header, Buffer.alloc(newCapacity)]);
+        this.capacityAfterHeader = newCapacity;
+    }
+}
+exports.Pickle = Pickle;
+//# sourceMappingURL=pickle.js.map
--- a/node_modules/@electron/asar/lib/pickle.js.map
+++ b/node_modules/@electron/asar/lib/pickle.js.map
--- a/node_modules/@electron/asar/lib/types/glob.d.ts
+++ b/node_modules/@electron/asar/lib/types/glob.d.ts
@ -0,0 +1,157 @@
+/**
+ * TODO(erikian): remove this file once we upgrade to the latest `glob` version.
+ * https://github.com/electron/asar/pull/332#issuecomment-2435407933
+ */
+interface IMinimatchOptions {
+    /**
+     * Dump a ton of stuff to stderr.
+     *
+     * @default false
+     */
+    debug?: boolean | undefined;
+    /**
+     * Do not expand `{a,b}` and `{1..3}` brace sets.
+     *
+     * @default false
+     */
+    nobrace?: boolean | undefined;
+    /**
+     * Disable `**` matching against multiple folder names.
+     *
+     * @default false
+     */
+    noglobstar?: boolean | undefined;
+    /**
+     * Allow patterns to match filenames starting with a period,
+     * even if the pattern does not explicitly have a period in that spot.
+     *
+     * Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
+     *
+     * @default false
+     */
+    dot?: boolean | undefined;
+    /**
+     * Disable "extglob" style patterns like `+(a|b)`.
+     *
+     * @default false
+     */
+    noext?: boolean | undefined;
+    /**
+     * Perform a case-insensitive match.
+     *
+     * @default false
+     */
+    nocase?: boolean | undefined;
+    /**
+     * When a match is not found by `minimatch.match`,
+     * return a list containing the pattern itself if this option is set.
+     * Otherwise, an empty list is returned if there are no matches.
+     *
+     * @default false
+     */
+    nonull?: boolean | undefined;
+    /**
+     * If set, then patterns without slashes will be matched
+     * against the basename of the path if it contains slashes. For example,
+     * `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+     *
+     * @default false
+     */
+    matchBase?: boolean | undefined;
+    /**
+     * Suppress the behavior of treating `#` at the start of a pattern as a comment.
+     *
+     * @default false
+     */
+    nocomment?: boolean | undefined;
+    /**
+     * Suppress the behavior of treating a leading `!` character as negation.
+     *
+     * @default false
+     */
+    nonegate?: boolean | undefined;
+    /**
+     * Returns from negate expressions the same as if they were not negated.
+     * (Ie, true on a hit, false on a miss.)
+     *
+     * @default false
+     */
+    flipNegate?: boolean | undefined;
+    /**
+     * Compare a partial path to a pattern.  As long as the parts of the path that
+     * are present are not contradicted by the pattern, it will be treated as a
+     * match. This is useful in applications where you're walking through a
+     * folder structure, and don't yet have the full path, but want to ensure that
+     * you do not walk down paths that can never be a match.
+     *
+     * @default false
+     *
+     * @example
+     * import minimatch = require("minimatch");
+     *
+     * minimatch('/a/b', '/a/*' + '/c/d', { partial: true })  // true, might be /a/b/c/d
+     * minimatch('/a/b', '/**' + '/d', { partial: true })     // true, might be /a/b/.../d
+     * minimatch('/x/y/z', '/a/**' + '/z', { partial: true }) // false, because x !== a
+     */
+    partial?: boolean;
+    /**
+     * Use `\\` as a path separator _only_, and _never_ as an escape
+     * character. If set, all `\\` characters are replaced with `/` in
+     * the pattern. Note that this makes it **impossible** to match
+     * against paths containing literal glob pattern characters, but
+     * allows matching with patterns constructed using `path.join()` and
+     * `path.resolve()` on Windows platforms, mimicking the (buggy!)
+     * behavior of earlier versions on Windows. Please use with
+     * caution, and be mindful of the caveat about Windows paths
+     *
+     * For legacy reasons, this is also set if
+     * `options.allowWindowsEscape` is set to the exact value `false`.
+     *
+     * @default false
+     */
+    windowsPathsNoEscape?: boolean;
+}
+export interface IOptions extends IMinimatchOptions {
+    cwd?: string | undefined;
+    root?: string | undefined;
+    dot?: boolean | undefined;
+    nomount?: boolean | undefined;
+    mark?: boolean | undefined;
+    nosort?: boolean | undefined;
+    stat?: boolean | undefined;
+    silent?: boolean | undefined;
+    strict?: boolean | undefined;
+    cache?: {
+        [path: string]: boolean | 'DIR' | 'FILE' | ReadonlyArray<string>;
+    } | undefined;
+    statCache?: {
+        [path: string]: false | {
+            isDirectory(): boolean;
+        } | undefined;
+    } | undefined;
+    symlinks?: {
+        [path: string]: boolean | undefined;
+    } | undefined;
+    realpathCache?: {
+        [path: string]: string;
+    } | undefined;
+    sync?: boolean | undefined;
+    nounique?: boolean | undefined;
+    nonull?: boolean | undefined;
+    debug?: boolean | undefined;
+    nobrace?: boolean | undefined;
+    noglobstar?: boolean | undefined;
+    noext?: boolean | undefined;
+    nocase?: boolean | undefined;
+    matchBase?: any;
+    nodir?: boolean | undefined;
+    ignore?: string | ReadonlyArray<string> | undefined;
+    follow?: boolean | undefined;
+    realpath?: boolean | undefined;
+    nonegate?: boolean | undefined;
+    nocomment?: boolean | undefined;
+    absolute?: boolean | undefined;
+    allowWindowsEscape?: boolean | undefined;
+    fs?: typeof import('fs');
+}
+export {};
--- a/node_modules/@electron/asar/lib/types/glob.js
+++ b/node_modules/@electron/asar/lib/types/glob.js
@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glob.js.map
--- a/node_modules/@electron/asar/lib/types/glob.js.map
+++ b/node_modules/@electron/asar/lib/types/glob.js.map
@ -0,0 +1 @@
+{"version":3,"file":"glob.js","sourceRoot":"","sources":["../../src/types/glob.ts"],"names":[],"mappings":""}
--- a/node_modules/@electron/asar/lib/wrapped-fs.d.ts
+++ b/node_modules/@electron/asar/lib/wrapped-fs.d.ts
@ -0,0 +1,13 @@
+type AsarFS = typeof import('fs') & {
+    mkdirp(dir: string): Promise<void>;
+    mkdirpSync(dir: string): void;
+    lstat: (typeof import('fs'))['promises']['lstat'];
+    mkdtemp: (typeof import('fs'))['promises']['mkdtemp'];
+    readFile: (typeof import('fs'))['promises']['readFile'];
+    stat: (typeof import('fs'))['promises']['stat'];
+    writeFile: (typeof import('fs'))['promises']['writeFile'];
+    symlink: (typeof import('fs'))['promises']['symlink'];
+    readlink: (typeof import('fs'))['promises']['readlink'];
+};
+declare const promisified: AsarFS;
+export default promisified;
--- a/node_modules/@electron/asar/lib/wrapped-fs.js
+++ b/node_modules/@electron/asar/lib/wrapped-fs.js
@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = 'electron' in process.versions ? require('original-fs') : require('fs');
+const promisifiedMethods = [
+    'lstat',
+    'mkdtemp',
+    'readFile',
+    'stat',
+    'writeFile',
+    'symlink',
+    'readlink',
+];
+const promisified = {};
+for (const method of Object.keys(fs)) {
+    if (promisifiedMethods.includes(method)) {
+        promisified[method] = fs.promises[method];
+    }
+    else {
+        promisified[method] = fs[method];
+    }
+}
+// To make it more like fs-extra
+promisified.mkdirp = (dir) => fs.promises.mkdir(dir, { recursive: true });
+promisified.mkdirpSync = (dir) => fs.mkdirSync(dir, { recursive: true });
+exports.default = promisified;
+//# sourceMappingURL=wrapped-fs.js.map
--- a/node_modules/@electron/asar/lib/wrapped-fs.js.map
+++ b/node_modules/@electron/asar/lib/wrapped-fs.js.map
@ -0,0 +1 @@
+{"version":3,"file":"wrapped-fs.js","sourceRoot":"","sources":["../src/wrapped-fs.ts"],"names":[],"mappings":";;AAAA,MAAM,EAAE,GAAG,UAAU,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnF,MAAM,kBAAkB,GAAG;IACzB,OAAO;IACP,SAAS;IACT,UAAU;IACV,MAAM;IACN,WAAW;IACX,SAAS;IACT,UAAU;CACX,CAAC;AAcF,MAAM,WAAW,GAAG,EAAY,CAAC;AAEjC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;IACrC,IAAI,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACvC,WAAmB,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;SAAM,CAAC;QACL,WAAmB,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC;AACD,gCAAgC;AAChC,WAAW,CAAC,MAAM,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC1E,WAAW,CAAC,UAAU,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAEzE,kBAAe,WAAW,CAAC"}
--- a/node_modules/@electron/asar/node_modules/balanced-match/.github/FUNDING.yml
+++ b/node_modules/@electron/asar/node_modules/balanced-match/.github/FUNDING.yml
@ -0,0 +1,2 @@
+tidelift: "npm/balanced-match"
+patreon: juliangruber
--- a/node_modules/@electron/asar/node_modules/balanced-match/LICENSE.md
+++ b/node_modules/@electron/asar/node_modules/balanced-match/LICENSE.md
@ -0,0 +1,21 @@
+(MIT)
+
+Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/@electron/asar/node_modules/balanced-match/README.md
+++ b/node_modules/@electron/asar/node_modules/balanced-match/README.md
@ -0,0 +1,97 @@
+# balanced-match
+
+Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
+
+[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
+[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
+
+[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
+
+## Example
+
+Get the first matching pair of braces:
+
+```js
+var balanced = require('balanced-match');
+
+console.log(balanced('{', '}', 'pre{in{nested}}post'));
+console.log(balanced('{', '}', 'pre{first}between{second}post'));
+console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'));
+```
+
+The matches are:
+
+```bash
+$ node example.js
+{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
+{ start: 3,
+  end: 9,
+  pre: 'pre',
+  body: 'first',
+  post: 'between{second}post' }
+{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
+```
+
+## API
+
+### var m = balanced(a, b, str)
+
+For the first non-nested matching pair of `a` and `b` in `str`, return an
+object with those keys:
+
+* **start** the index of the first match of `a`
+* **end** the index of the matching `b`
+* **pre** the preamble, `a` and `b` not included
+* **body** the match, `a` and `b` not included
+* **post** the postscript, `a` and `b` not included
+
+If there's no match, `undefined` will be returned.
+
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
+
+### var r = balanced.range(a, b, str)
+
+For the first non-nested matching pair of `a` and `b` in `str`, return an
+array with indexes: `[ <a index>, <b index> ]`.
+
+If there's no match, `undefined` will be returned.
+
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
+
+## Installation
+
+With [npm](https://npmjs.org) do:
+
+```bash
+npm install balanced-match
+```
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/@electron/asar/node_modules/balanced-match/index.js
+++ b/node_modules/@electron/asar/node_modules/balanced-match/index.js
@ -0,0 +1,62 @@
+'use strict';
+module.exports = balanced;
+function balanced(a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str);
+  if (b instanceof RegExp) b = maybeMatch(b, str);
+
+  var r = range(a, b, str);
+
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + a.length, r[1]),
+    post: str.slice(r[1] + b.length)
+  };
+}
+
+function maybeMatch(reg, str) {
+  var m = str.match(reg);
+  return m ? m[0] : null;
+}
+
+balanced.range = range;
+function range(a, b, str) {
+  var begs, beg, left, right, result;
+  var ai = str.indexOf(a);
+  var bi = str.indexOf(b, ai + 1);
+  var i = ai;
+
+  if (ai >= 0 && bi > 0) {
+    if(a===b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+
+    while (i >= 0 && !result) {
+      if (i == ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length == 1) {
+        result = [ begs.pop(), bi ];
+      } else {
+        beg = begs.pop();
+        if (beg < left) {
+          left = beg;
+          right = bi;
+        }
+
+        bi = str.indexOf(b, i + 1);
+      }
+
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+
+    if (begs.length) {
+      result = [ left, right ];
+    }
+  }
+
+  return result;
+}
--- a/node_modules/@electron/asar/node_modules/balanced-match/package.json
+++ b/node_modules/@electron/asar/node_modules/balanced-match/package.json
@ -0,0 +1,48 @@
+{
+  "name": "balanced-match",
+  "description": "Match balanced character pairs, like \"{\" and \"}\"",
+  "version": "1.0.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/juliangruber/balanced-match.git"
+  },
+  "homepage": "https://github.com/juliangruber/balanced-match",
+  "main": "index.js",
+  "scripts": {
+    "test": "tape test/test.js",
+    "bench": "matcha test/bench.js"
+  },
+  "devDependencies": {
+    "matcha": "^0.7.0",
+    "tape": "^4.6.0"
+  },
+  "keywords": [
+    "match",
+    "regexp",
+    "test",
+    "balanced",
+    "parse"
+  ],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT",
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/20..latest",
+      "firefox/nightly",
+      "chrome/25..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}
--- a/node_modules/@electron/asar/node_modules/brace-expansion/LICENSE
+++ b/node_modules/@electron/asar/node_modules/brace-expansion/LICENSE
@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/@electron/asar/node_modules/brace-expansion/README.md
+++ b/node_modules/@electron/asar/node_modules/brace-expansion/README.md
@ -0,0 +1,129 @@
+# brace-expansion
+
+[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), 
+as known from sh/bash, in JavaScript.
+
+[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
+[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
+[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
+
+[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
+
+## Example
+
+```js
+var expand = require('brace-expansion');
+
+expand('file-{a,b,c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('-v{,,}')
+// => ['-v', '-v', '-v']
+
+expand('file{0..2}.jpg')
+// => ['file0.jpg', 'file1.jpg', 'file2.jpg']
+
+expand('file-{a..c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('file{2..0}.jpg')
+// => ['file2.jpg', 'file1.jpg', 'file0.jpg']
+
+expand('file{0..4..2}.jpg')
+// => ['file0.jpg', 'file2.jpg', 'file4.jpg']
+
+expand('file-{a..e..2}.jpg')
+// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg']
+
+expand('file{00..10..5}.jpg')
+// => ['file00.jpg', 'file05.jpg', 'file10.jpg']
+
+expand('{{A..C},{a..c}}')
+// => ['A', 'B', 'C', 'a', 'b', 'c']
+
+expand('ppp{,config,oe{,conf}}')
+// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']
+```
+
+## API
+
+```js
+var expand = require('brace-expansion');
+```
+
+### var expanded = expand(str)
+
+Return an array of all possible and valid expansions of `str`. If none are
+found, `[str]` is returned.
+
+Valid expansions are:
+
+```js
+/^(.*,)+(.+)?$/
+// {a,b,...}
+```
+
+A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+A numeric sequence from `x` to `y` inclusive, with optional increment.
+If `x` or `y` start with a leading `0`, all the numbers will be padded
+to have equal length. Negative numbers and backwards iteration work too.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+An alphabetic sequence from `x` to `y` inclusive, with optional increment.
+`x` and `y` must be exactly one character, and if given, `incr` must be a
+number.
+
+For compatibility reasons, the string `${` is not eligible for brace expansion.
+
+## Installation
+
+With [npm](https://npmjs.org) do:
+
+```bash
+npm install brace-expansion
+```
+
+## Contributors
+
+- [Julian Gruber](https://github.com/juliangruber)
+- [Isaac Z. Schlueter](https://github.com/isaacs)
+
+## Sponsors
+
+This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!
+
+Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/@electron/asar/node_modules/brace-expansion/index.js
+++ b/node_modules/@electron/asar/node_modules/brace-expansion/index.js
@ -0,0 +1,203 @@
+var concatMap = require('concat-map');
+var balanced = require('balanced-match');
+
+module.exports = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
+
+  var parts = [];
+  var m = balanced('{', '}', str);
+
+  if (!m)
+    return str.split(',');
+
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+
+  parts.push.apply(parts, p);
+
+  return parts;
+}
+
+function expandTop(str, options) {
+  if (!str)
+    return [];
+
+  options = options || {};
+  var max = options.max == null ? Infinity : options.max;
+
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
+
+  return expand(escapeBraces(str), max, true).map(unescapeBraces);
+}
+
+function identity(e) {
+  return e;
+}
+
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+
+function expand(str, max, isTop) {
+  var expansions = [];
+
+  var m = balanced('{', '}', str);
+  if (!m || /\$$/.test(m.pre)) return [str];
+
+  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+  var isSequence = isNumericSequence || isAlphaSequence;
+  var isOptions = m.body.indexOf(',') >= 0;
+  if (!isSequence && !isOptions) {
+    // {a},b}
+    if (m.post.match(/,(?!,).*\}/)) {
+      str = m.pre + '{' + m.body + escClose + m.post;
+      return expand(str, max, true);
+    }
+    return [str];
+  }
+
+  var n;
+  if (isSequence) {
+    n = m.body.split(/\.\./);
+  } else {
+    n = parseCommaParts(m.body);
+    if (n.length === 1) {
+      // x{{a,b}}y ==> x{a}y x{b}y
+      n = expand(n[0], max, false).map(embrace);
+      if (n.length === 1) {
+        var post = m.post.length
+          ? expand(m.post, max, false)
+          : [''];
+        return post.map(function(p) {
+          return m.pre + n[0] + p;
+        });
+      }
+    }
+  }
+
+  // at this point, n is the parts, and we know it's not a comma set
+  // with a single entry.
+
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand(m.post, max, false)
+    : [''];
+
+  var N;
+
+  if (isSequence) {
+    var x = numeric(n[0]);
+    var y = numeric(n[1]);
+    var width = Math.max(n[0].length, n[1].length)
+    var incr = n.length == 3
+      ? Math.max(Math.abs(numeric(n[2])), 1)
+      : 1;
+    var test = lte;
+    var reverse = y < x;
+    if (reverse) {
+      incr *= -1;
+      test = gte;
+    }
+    var pad = n.some(isPadded);
+
+    N = [];
+
+    for (var i = x; test(i, y); i += incr) {
+      var c;
+      if (isAlphaSequence) {
+        c = String.fromCharCode(i);
+        if (c === '\\')
+          c = '';
+      } else {
+        c = String(i);
+        if (pad) {
+          var need = width - c.length;
+          if (need > 0) {
+            var z = new Array(need + 1).join('0');
+            if (i < 0)
+              c = '-' + z + c.slice(1);
+            else
+              c = z + c;
+          }
+        }
+      }
+      N.push(c);
+    }
+  } else {
+    N = concatMap(n, function(el) { return expand(el, max, false) });
+  }
+
+  for (var j = 0; j < N.length; j++) {
+    for (var k = 0; k < post.length && expansions.length < max; k++) {
+      var expansion = pre + N[j] + post[k];
+      if (!isTop || isSequence || expansion)
+        expansions.push(expansion);
+    }
+  }
+
+  return expansions;
+}
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`../@electron/osx-sign/bin/electron-osx-flat.js`
				`@ -0,0 +1 @@`
				{"version":3,"file":"crawlfs.js","sourceRoot":"","sources":["../src/crawlfs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,8CAUC;AAED,sBA8BC;AA7DD,+BAAiC;AACjC,+BAAqC;AAErC,8DAA8B;AAE9B,2CAA6B;AAG7B,MAAM,IAAI,GAAG,IAAA,gBAAS,EAAC,WAAK,CAAC,CAAC;AAWvB,KAAK,UAAU,iBAAiB,CAAC,QAAgB;IACtD,MAAM,IAAI,GAAG,MAAM,oBAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QAClB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAChC,CAAC;SAAM,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;IACrC,CAAC;SAAM,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QACjC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAChC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAEM,KAAK,UAAU,KAAK,CAAC,GAAW,EAAE,OAAiB;IACxD,MAAM,QAAQ,GAAoC,EAAE,CAAC;IACrD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAU,CAAC,CACxF,CAAC;IACF,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,SAAS,GAAG,OAAO;SACtB,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,EAAE;QACxB,IAAI,IAAI,EAAE,CAAC;YACT,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;YAC1B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE;QACnB,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,cAAc,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC;QACpE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,KAAK,KAAK,cAAc,EAAE,CAAC;gBAC7B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,sBAAsB,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACzD,uFAAuF;YACvF,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YACjE,OAAO,CAAC,sBAAsB,IAAI,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACL,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAU,CAAC;AACxC,CAAC"}
				`@ -0,0 +1 @@`
				{"version":3,"file":"integrity.js","sourceRoot":"","sources":["../src/integrity.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,4CA8CC;AApED,+CAAiC;AAEjC,+CAAiC;AACjC,+BAAiC;AAEjC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAC3B,yBAAyB;AACzB,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAEnC,MAAM,QAAQ,GAAG,IAAA,gBAAS,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAE5C,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC;AASM,KAAK,UAAU,gBAAgB,CACpC,eAAsC;IAEtC,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAE9C,MAAM,WAAW,GAAa,EAAE,CAAC;IACjC,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,IAAI,YAAY,GAAa,EAAE,CAAC;IAEhC,MAAM,QAAQ,CACZ,eAAe,EACf,IAAI,MAAM,CAAC,WAAW,CAAC;QACrB,aAAa,EAAE,KAAK;QACpB,SAAS,CAAC,MAAc,EAAE,QAAQ,EAAE,QAAQ;YAC1C,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAExB,SAAS,WAAW,CAAC,KAAa;gBAChC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;gBAC9E,gBAAgB,IAAI,WAAW,CAAC;gBAChC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;gBAC/C,IAAI,gBAAgB,KAAK,UAAU,EAAE,CAAC;oBACpC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBACzD,YAAY,GAAG,EAAE,CAAC;oBAClB,gBAAgB,GAAG,CAAC,CAAC;gBACvB,CAAC;gBACD,IAAI,WAAW,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;oBACnC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YACD,WAAW,CAAC,MAAM,CAAC,CAAC;YACpB,QAAQ,EAAE,CAAC;QACb,CAAC;QACD,KAAK,CAAC,QAAQ;YACZ,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACzD,YAAY,GAAG,EAAE,CAAC;YAClB,QAAQ,EAAE,CAAC;QACb,CAAC;KACF,CAAC,CACH,CAAC;IAEF,OAAO;QACL,SAAS,EAAE,SAAS;QACpB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC;QAC5B,SAAS,EAAE,UAAU;QACrB,MAAM,EAAE,WAAW;KACpB,CAAC;AACJ,CAAC"}
				`@ -0,0 +1 @@`
				`{"version":3,"file":"glob.js","sourceRoot":"","sources":["../../src/types/glob.ts"],"names":[],"mappings":""}`
				`@ -0,0 +1 @@`
				{"version":3,"file":"wrapped-fs.js","sourceRoot":"","sources":["../src/wrapped-fs.ts"],"names":[],"mappings":";;AAAA,MAAM,EAAE,GAAG,UAAU,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnF,MAAM,kBAAkB,GAAG;IACzB,OAAO;IACP,SAAS;IACT,UAAU;IACV,MAAM;IACN,WAAW;IACX,SAAS;IACT,UAAU;CACX,CAAC;AAcF,MAAM,WAAW,GAAG,EAAY,CAAC;AAEjC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;IACrC,IAAI,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACvC,WAAmB,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;SAAM,CAAC;QACL,WAAmB,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC;AACD,gCAAgC;AAChC,WAAW,CAAC,MAAM,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC1E,WAAW,CAAC,UAAU,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAEzE,kBAAe,WAAW,CAAC"}