Removed files that should not have been included in git

12 files changed, 0 insertions, 1238 deletions

diff --git a/node_modules/asar/CHANGELOG.md b/node_modules/asar/CHANGELOG.md
deleted file mode 100644
index d112929..0000000
--- a/node_modules/asar/CHANGELOG.md
+++ /dev/null
@@ -1,140 +0,0 @@
-# [3.2.0](https://github.com/electron/asar/compare/v3.1.0...v3.2.0) (2022-07-29)
-
-
-### Features
-
-* give better hints when failing due to bad links ([#241](https://github.com/electron/asar/issues/241)) ([db6d154](https://github.com/electron/asar/commit/db6d1541be05f67933f07c6f30d2425a05f13182))
-
-# Changes By Version
-
-## [2.0.1](https://github.com/electron/asar/compare/v2.0.0...v2.0.1) - 2019-04-29
-
-### Fixed
-
-* Don't monkeypatch fs with promisified versions ([#176](https://github.com/electron/asar/issues/176)) ([319dd81](https://github.com/electron/asar/commit/319dd81))
-
-## [2.0.0](https://github.com/electron/asar/compare/v1.0.0...v2.0.0) - 2019-04-27
-
-### Removed
-
-* Support for Node < 8 ([#170](https://github.com/electron/asar/issues/170)) ([8a03eae](https://github.com/electron/asar/commit/8a03eae))
-
-## 1.0.0 - 2019-02-19
-
-### Added
-
-* Promise-based async API (#165)
-
-### Changed
-
-* This module requires Node 6 or later (#165)
-
-### Removed
-
-* V8 snapshot support, which was undocumented and used an unmaintained dependency, which itself had a dependency with a security vulnerability (#165)
-* callback-style async API - if you still need to use this style of API, please check out the `nodeify` module (#165)
-
-## 0.14.6 - 2018-12-10
-
-### Fixed
-
-* Normalize file paths in `asar.createPackageFromFiles` (#159)
-
-## 0.14.5 - 2018-10-01
-
-### Fixed
-
-* Regression from #154
-
-## 0.14.4 - 2018-09-30
-
-### Added
-
-* `--is-pack` CLI option / `isPack` option to `asar.listPackage` (#145)
-
-### Fixed
-
-* Allow `asar.createPackageFromFiles` to not pass `metadata` or `options` (#154)
-
-## 0.14.3 - 2018-03-07
-
-### Added
-
-* `globOptions` option to pass options to the `glob` module
-* `pattern` option
-
-## 0.14.2 - 2018-02-11
-
-### Fixed
-
-* Invoke callback if the last file in the list was marked as unpacked (#142)
-
-## 0.14.1 - 2018-01-30
-
-### Fixed
-
-* Maximum call stack size exceeded during unpack (#140)
-
-## 0.14.0 - 2017-11-02
-
-### Added
-
-* Snapcraft metadata (#130)
-* `uncache` and `uncacheAll` (#118)
-
-### Fixed
-
-* Use of asar inside of an Electron app (#118)
-
-## 0.13.1 - 2017-11-02
-
-### Fixed
-
-- Do not return before the write stream fully closes (#113)
-
-## 0.13.0 - 2017-01-09
-
-### Changed
-
-- Dropped support for Node `0.10.0` and `0.12.0`. The minimum supported version
-  is now Node `4.6.0`. (#100)
-- This project was ported from CoffeeScript to JavaScript. The behavior and
-  APIs should be the same as previous releases. (#100)
-
-## 0.12.4 - 2016-12-28
-
-### Fixed
-
-- Unpack glob patterns containing `{}` characters not working properly (#99)
-
-## 0.12.3 - 2016-08-29
-
-### Fixed
-
-- Multibyte characters in paths are now supported (#86)
-
-## 0.12.2 - 2016-08-22
-
-### Fixed
-
-- Upgraded `minimatch` to `^3.0.3` from `^3.0.0` for [RegExp DOS fix](https://nodesecurity.io/advisories/minimatch_regular-expression-denial-of-service).
-
-## 0.12.1 - 2016-07-25
-
-### Fixed
-
-- Fix `Maximum call stack size exceeded` error regression (#80)
-
-## 0.12.0 - 2016-07-20
-
-### Added
-
-- Added `transform` option to specify a `stream.Transform` function to the
-  `createPackageWithOptions` API (#73)
-
-## 0.11.0 - 2016-04-06
-
-### Fixed
-
-- Upgraded `mksnapshot` dependency to remove logged `graceful-fs` deprecation
-  warnings (#61)
diff --git a/node_modules/asar/LICENSE.md b/node_modules/asar/LICENSE.md
deleted file mode 100644
index 4d231b4..0000000
--- a/node_modules/asar/LICENSE.md
+++ /dev/null
@@ -1,20 +0,0 @@
-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.
diff --git a/node_modules/asar/README.md b/node_modules/asar/README.md
deleted file mode 100644
index b9f2568..0000000
--- a/node_modules/asar/README.md
+++ /dev/null
@@ -1,215 +0,0 @@
-# asar - Electron Archive
-
-[![CircleCI build status](https://circleci.com/gh/electron/asar/tree/main.svg?style=shield)](https://circleci.com/gh/electron/asar/tree/main)
-[![npm version](http://img.shields.io/npm/v/asar.svg)](https://npmjs.org/package/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 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 programatically
-
-### Example
-
-```javascript
-const asar = require('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('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.');
-```
-
-## Using with grunt
-
-There is also an unofficial grunt plugin to generate asar archives at [bwin/grunt-asar][grunt-asar].
-
-## Format
-
-Asar uses [Pickle][pickle] to safely serialize binary value to file, there is
-also a [node.js binding][node-pickle] of `Pickle` class.
-
-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/+/master/base/pickle.h
-[node-pickle]: https://www.npmjs.org/package/chromium-pickle
-[grunt-asar]: https://github.com/bwin/grunt-asar
diff --git a/node_modules/asar/bin/asar.js b/node_modules/asar/bin/asar.js
deleted file mode 100755
index 8efcc1a..0000000
--- a/node_modules/asar/bin/asar.js
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/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, function (error) {
-      if (error) {
-        console.error(error.stack)
-        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) {
-    console.log('asar: \'%s\' is not an asar command. See \'asar --help\'.', cmd)
-  })
-
-program.parse(process.argv)
-
-if (program.args.length === 0) {
-  program.help()
-}
diff --git a/node_modules/asar/lib/asar.js b/node_modules/asar/lib/asar.js
deleted file mode 100644
index 050e1a7..0000000
--- a/node_modules/asar/lib/asar.js
+++ /dev/null
@@ -1,219 +0,0 @@
-'use strict'
-
-const fs = require('./wrapped-fs')
-const path = require('path')
-const minimatch = require('minimatch')
-
-const Filesystem = require('./filesystem')
-const disk = require('./disk')
-const crawlFilesystem = require('./crawlfs')
-
-/**
- * Whether a directory should be excluded from packing due to the `--unpack-dir" option.
- *
- * @param {string} dirPath - directory path to check
- * @param {string} pattern - literal prefix [for backward compatibility] or glob pattern
- * @param {array} unpackDirs - Array of directory paths previously marked as unpacked
- */
-function isUnpackedDir (dirPath, pattern, unpackDirs) {
-  if (dirPath.startsWith(pattern) || minimatch(dirPath, pattern)) {
-    if (!unpackDirs.includes(dirPath)) {
-      unpackDirs.push(dirPath)
-    }
-    return true
-  } else {
-    return unpackDirs.some(unpackDir => dirPath.startsWith(unpackDir))
-  }
-}
-
-module.exports.createPackage = async function (src, dest) {
-  return module.exports.createPackageWithOptions(src, dest, {})
-}
-
-module.exports.createPackageWithOptions = async function (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 crawlFilesystem(pattern, globOptions)
-  return module.exports.createPackageFromFiles(src, dest, filenames, metadata, options)
-}
-
-/**
- * Create an ASAR archive from a list of filenames.
- *
- * @param {string} src: Base path. All files are relative to this.
- * @param {string} dest: Archive filename (& path).
- * @param {array} filenames: List of filenames relative to src.
- * @param {object} metadata: Object with filenames as keys and {type='directory|file|link', stat: fs.stat} as values. (Optional)
- * @param {object} options: Options passed to `createPackageWithOptions`.
-*/
-module.exports.createPackageFromFiles = async function (src, dest, filenames, metadata, options) {
-  if (typeof metadata === 'undefined' || metadata === null) { metadata = {} }
-  if (typeof options === 'undefined' || options === null) { options = {} }
-
-  src = path.normalize(src)
-  dest = path.normalize(dest)
-  filenames = filenames.map(function (filename) { return path.normalize(filename) })
-
-  const filesystem = new Filesystem(src)
-  const files = []
-  const unpackDirs = []
-
-  let filenamesSorted = []
-  if (options.ordering) {
-    const orderingFiles = (await fs.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]) {
-      metadata[filename] = await crawlFilesystem.determineFileType(filename)
-    }
-    const file = metadata[filename]
-
-    let shouldUnpack
-    switch (file.type) {
-      case 'directory':
-        if (options.unpackDir) {
-          shouldUnpack = isUnpackedDir(path.relative(src, filename), options.unpackDir, unpackDirs)
-        } else {
-          shouldUnpack = false
-        }
-        filesystem.insertDirectory(filename, shouldUnpack)
-        break
-      case 'file':
-        shouldUnpack = false
-        if (options.unpack) {
-          shouldUnpack = minimatch(filename, options.unpack, { matchBase: true })
-        }
-        if (!shouldUnpack && options.unpackDir) {
-          const dirName = path.relative(src, path.dirname(filename))
-          shouldUnpack = isUnpackedDir(dirName, options.unpackDir, unpackDirs)
-        }
-        files.push({ filename: filename, unpack: shouldUnpack })
-        return filesystem.insertFile(filename, shouldUnpack, file, options)
-      case 'link':
-        filesystem.insertLink(filename)
-        break
-    }
-    return Promise.resolve()
-  }
-
-  const insertsDone = async function () {
-    await fs.mkdirp(path.dirname(dest))
-    return disk.writeFilesystem(dest, filesystem, files, 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())
-}
-
-module.exports.statFile = function (archive, filename, followLinks) {
-  const filesystem = disk.readFilesystemSync(archive)
-  return filesystem.getFile(filename, followLinks)
-}
-
-module.exports.getRawHeader = function (archive) {
-  return disk.readArchiveHeaderSync(archive)
-}
-
-module.exports.listPackage = function (archive, options) {
-  return disk.readFilesystemSync(archive).listFiles(options)
-}
-
-module.exports.extractFile = function (archive, filename) {
-  const filesystem = disk.readFilesystemSync(archive)
-  return disk.readFileSync(filesystem, filename, filesystem.getFile(filename))
-}
-
-module.exports.extractAll = function (archive, dest) {
-  const filesystem = disk.readFilesystemSync(archive)
-  const filenames = filesystem.listFiles()
-
-  // under windows just extract links as regular files
-  const followLinks = process.platform === 'win32'
-
-  // create destination directory
-  fs.mkdirpSync(dest)
-
-  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 (file.files) {
-      // it's a directory, create it and continue with the next entry
-      fs.mkdirpSync(destFilename)
-    } else if (file.link) {
-      // 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 {
-        fs.unlinkSync(destFilename)
-      } catch {}
-      const linkTo = path.join(relativePath, path.basename(file.link))
-      fs.symlinkSync(linkTo, destFilename)
-    } else {
-      // it's a file, extract it
-      const content = disk.readFileSync(filesystem, filename, file)
-      fs.writeFileSync(destFilename, content)
-      if (file.executable) {
-        fs.chmodSync(destFilename, '755')
-      }
-    }
-  }
-}
-
-module.exports.uncache = function (archive) {
-  return disk.uncacheFilesystem(archive)
-}
-
-module.exports.uncacheAll = function () {
-  disk.uncacheAll()
-}
diff --git a/node_modules/asar/lib/crawlfs.js b/node_modules/asar/lib/crawlfs.js
deleted file mode 100644
index a26c3eb..0000000
--- a/node_modules/asar/lib/crawlfs.js
+++ /dev/null
@@ -1,41 +0,0 @@
-'use strict'
-
-const { promisify } = require('util')
-
-const fs = require('./wrapped-fs')
-const glob = promisify(require('glob'))
-
-async function determineFileType (filename) {
-  const stat = await fs.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 }
-  }
-}
-
-module.exports = async function (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
-      return !filename.startsWith(link)
-    })
-  })
-  return [filenames, metadata]
-}
-module.exports.determineFileType = determineFileType
diff --git a/node_modules/asar/lib/disk.js b/node_modules/asar/lib/disk.js
deleted file mode 100644
index 34569a4..0000000
--- a/node_modules/asar/lib/disk.js
+++ /dev/null
@@ -1,123 +0,0 @@
-'use strict'
-
-const fs = require('./wrapped-fs')
-const path = require('path')
-const pickle = require('chromium-pickle-js')
-
-const Filesystem = require('./filesystem')
-let filesystemCache = {}
-
-async function copyFile (dest, src, filename) {
-  const srcFile = path.join(src, filename)
-  const targetFile = path.join(dest, filename)
-
-  const [content, stats] = await Promise.all([fs.readFile(srcFile), fs.stat(srcFile), fs.mkdirp(path.dirname(targetFile))])
-  return fs.writeFile(targetFile, content, { mode: stats.mode })
-}
-
-async function streamTransformedFile (originalFilename, outStream, transformed) {
-  return new Promise((resolve, reject) => {
-    const stream = fs.createReadStream(transformed ? transformed.path : originalFilename)
-    stream.pipe(outStream, { end: false })
-    stream.on('error', reject)
-    stream.on('end', () => resolve())
-  })
-}
-
-const writeFileListToStream = async function (dest, filesystem, out, list, metadata) {
-  for (const file of list) {
-    if (file.unpack) { // the file should not be packed into archive
-      const filename = path.relative(filesystem.src, file.filename)
-      await copyFile(`${dest}.unpacked`, filesystem.src, filename)
-    } else {
-      await streamTransformedFile(file.filename, out, metadata[file.filename].transformed)
-    }
-  }
-  return out.end()
-}
-
-module.exports.writeFilesystem = async function (dest, filesystem, files, metadata) {
-  const headerPickle = pickle.createEmpty()
-  headerPickle.writeString(JSON.stringify(filesystem.header))
-  const headerBuf = headerPickle.toBuffer()
-
-  const sizePickle = pickle.createEmpty()
-  sizePickle.writeUInt32(headerBuf.length)
-  const sizeBuf = sizePickle.toBuffer()
-
-  const out = fs.createWriteStream(dest)
-  await new Promise((resolve, reject) => {
-    out.on('error', reject)
-    out.write(sizeBuf)
-    return out.write(headerBuf, () => resolve())
-  })
-  return writeFileListToStream(dest, filesystem, out, files, metadata)
-}
-
-module.exports.readArchiveHeaderSync = function (archive) {
-  const fd = fs.openSync(archive, 'r')
-  let size
-  let headerBuf
-  try {
-    const sizeBuf = Buffer.alloc(8)
-    if (fs.readSync(fd, sizeBuf, 0, 8, null) !== 8) {
-      throw new Error('Unable to read header size')
-    }
-
-    const sizePickle = pickle.createFromBuffer(sizeBuf)
-    size = sizePickle.createIterator().readUInt32()
-    headerBuf = Buffer.alloc(size)
-    if (fs.readSync(fd, headerBuf, 0, size, null) !== size) {
-      throw new Error('Unable to read header')
-    }
-  } finally {
-    fs.closeSync(fd)
-  }
-
-  const headerPickle = pickle.createFromBuffer(headerBuf)
-  const header = headerPickle.createIterator().readString()
-  return { headerString: header, header: JSON.parse(header), headerSize: size }
-}
-
-module.exports.readFilesystemSync = function (archive) {
-  if (!filesystemCache[archive]) {
-    const header = this.readArchiveHeaderSync(archive)
-    const filesystem = new Filesystem(archive)
-    filesystem.header = header.header
-    filesystem.headerSize = header.headerSize
-    filesystemCache[archive] = filesystem
-  }
-  return filesystemCache[archive]
-}
-
-module.exports.uncacheFilesystem = function (archive) {
-  if (filesystemCache[archive]) {
-    filesystemCache[archive] = undefined
-    return true
-  }
-  return false
-}
-
-module.exports.uncacheAll = function () {
-  filesystemCache = {}
-}
-
-module.exports.readFileSync = function (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 = fs.readFileSync(path.join(`${filesystem.src}.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 = fs.openSync(filesystem.src, 'r')
-    try {
-      const offset = 8 + filesystem.headerSize + parseInt(info.offset)
-      fs.readSync(fd, buffer, 0, info.size, offset)
-    } finally {
-      fs.closeSync(fd)
-    }
-  }
-  return buffer
-}
diff --git a/node_modules/asar/lib/filesystem.js b/node_modules/asar/lib/filesystem.js
deleted file mode 100644
index 552055e..0000000
--- a/node_modules/asar/lib/filesystem.js
+++ /dev/null
@@ -1,151 +0,0 @@
-'use strict'
-
-const fs = require('./wrapped-fs')
-const os = require('os')
-const path = require('path')
-const { promisify } = require('util')
-const stream = require('stream')
-const getFileIntegrity = require('./integrity')
-
-const UINT32_MAX = 2 ** 32 - 1
-
-const pipeline = promisify(stream.pipeline)
-
-class Filesystem {
-  constructor (src) {
-    this.src = path.resolve(src)
-    this.header = { files: {} }
-    this.offset = BigInt(0)
-  }
-
-  searchNodeFromDirectory (p) {
-    let json = this.header
-    const dirs = p.split(path.sep)
-    for (const dir of dirs) {
-      if (dir !== '.') {
-        json = json.files[dir]
-      }
-    }
-    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 == null) {
-      node.files = {}
-    }
-    if (node.files[name] == null) {
-      node.files[name] = {}
-    }
-    return node.files[name]
-  }
-
-  insertDirectory (p, shouldUnpack) {
-    const node = this.searchNodeFromPath(p)
-    if (shouldUnpack) {
-      node.unpacked = shouldUnpack
-    }
-    node.files = {}
-    return node.files
-  }
-
-  async insertFile (p, 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 getFileIntegrity(p)
-      return Promise.resolve()
-    }
-
-    let size
-
-    const transformed = options.transform && options.transform(p)
-    if (transformed) {
-      const tmpdir = await fs.mkdtemp(path.join(os.tmpdir(), 'asar-'))
-      const tmpfile = path.join(tmpdir, path.basename(p))
-      const out = fs.createWriteStream(tmpfile)
-      const readStream = fs.createReadStream(p)
-
-      await pipeline(readStream, transformed, out)
-      file.transformed = {
-        path: tmpfile,
-        stat: await fs.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 getFileIntegrity(p)
-    if (process.platform !== 'win32' && (file.stat.mode & 0o100)) {
-      node.executable = true
-    }
-    this.offset += BigInt(size)
-  }
-
-  insertLink (p) {
-    const link = path.relative(fs.realpathSync(this.src), fs.realpathSync(p))
-    if (link.substr(0, 2) === '..') {
-      throw new Error(`${p}: file "${link}" links out of the package`)
-    }
-    const node = this.searchNodeFromPath(p)
-    node.link = link
-    return link
-  }
-
-  listFiles (options) {
-    const files = []
-
-    const fillFilesFromMetadata = function (basePath, metadata) {
-      if (!metadata.files) {
-        return
-      }
-
-      for (const [childPath, childMetadata] of Object.entries(metadata.files)) {
-        const fullPath = path.join(basePath, childPath)
-        const packState = childMetadata.unpacked ? 'unpack' : 'pack  '
-        files.push((options && options.isPack) ? `${packState} : ${fullPath}` : fullPath)
-        fillFilesFromMetadata(fullPath, childMetadata)
-      }
-    }
-
-    fillFilesFromMetadata('/', this.header)
-    return files
-  }
-
-  getNode (p) {
-    const node = this.searchNodeFromDirectory(path.dirname(p))
-    const name = path.basename(p)
-    if (name) {
-      return node.files[name]
-    } else {
-      return node
-    }
-  }
-
-  getFile (p, followLinks) {
-    followLinks = typeof followLinks === 'undefined' ? true : followLinks
-    const info = this.getNode(p)
-
-    // if followLinks is false we don't resolve symlinks
-    if (info.link && followLinks) {
-      return this.getFile(info.link)
-    } else {
-      return info
-    }
-  }
-}
-
-module.exports = Filesystem
diff --git a/node_modules/asar/lib/index.d.ts b/node_modules/asar/lib/index.d.ts
deleted file mode 100644
index b3790ec..0000000
--- a/node_modules/asar/lib/index.d.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { IOptions as GlobOptions } from 'glob';
-import { Stats } from 'fs';
-
-export type CreateOptions = {
-  dot?: boolean;
-  globOptions?: GlobOptions;
-  ordering?: string;
-  pattern?: string;
-  transform?: (filePath: string) => NodeJS.ReadWriteStream | void;
-  unpack?: string;
-  unpackDir?: string;
-};
-
-export type ListOptions = {
-  isPack: boolean;
-};
-
-export type EntryMetadata = {
-  unpacked: boolean;
-};
-
-export type DirectoryMetadata = EntryMetadata & {
-  files: { [property: string]: EntryMetadata };
-};
-
-export type FileMetadata = EntryMetadata & {
-  executable?: true;
-  offset?: number;
-  size?: number;
-};
-
-export type LinkMetadata = {
-  link: string;
-};
-
-export type Metadata = DirectoryMetadata | FileMetadata | LinkMetadata;
-
-export type InputMetadataType = 'directory' | 'file' | 'link';
-
-export type InputMetadata = {
-  [property: string]: {
-    type: InputMetadataType;
-    stat: Stats;
-  }
-};
-
-export type DirectoryRecord = {
-  files: Record<string, DirectoryRecord | FileRecord>;
-};
-
-export type FileRecord = {
-  offset: string;
-  size: number;
-  executable?: boolean;
-  integrity: {
-    hash: string;
-    algorithm: 'SHA256';
-    blocks: string[];
-    blockSize: number;
-  };
-}
-
-export type ArchiveHeader = {
-  // The JSON parsed header string
-  header: DirectoryRecord;
-  headerString: string;
-  headerSize: number;
-}
-
-export function createPackage(src: string, dest: string): Promise<void>;
-export function createPackageWithOptions(
-  src: string,
-  dest: string,
-  options: CreateOptions
-): Promise<void>;
-export function createPackageFromFiles(
-  src: string,
-  dest: string,
-  filenames: string[],
-  metadata?: InputMetadata,
-  options?: CreateOptions
-): Promise<void>;
-
-export function statFile(archive: string, filename: string, followLinks?: boolean): Metadata;
-export function getRawHeader(archive: string): ArchiveHeader;
-export function listPackage(archive: string, options?: ListOptions): string[];
-export function extractFile(archive: string, filename: string): Buffer;
-export function extractAll(archive: string, dest: string): void;
-export function uncache(archive: string): boolean;
-export function uncacheAll(): void;
diff --git a/node_modules/asar/lib/integrity.js b/node_modules/asar/lib/integrity.js
deleted file mode 100644
index 6fabee4..0000000
--- a/node_modules/asar/lib/integrity.js
+++ /dev/null
@@ -1,62 +0,0 @@
-const crypto = require('crypto')
-const fs = require('fs')
-const stream = require('stream')
-const { promisify } = require('util')
-
-const ALGORITHM = 'SHA256'
-// 4MB default block size
-const BLOCK_SIZE = 4 * 1024 * 1024
-
-const pipeline = promisify(stream.pipeline)
-
-function hashBlock (block) {
-  return crypto.createHash(ALGORITHM).update(block).digest('hex')
-}
-
-async function getFileIntegrity (path) {
-  const fileHash = crypto.createHash(ALGORITHM)
-
-  const blocks = []
-  let currentBlockSize = 0
-  let currentBlock = []
-
-  await pipeline(
-    fs.createReadStream(path),
-    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) {
-            blocks.push(hashBlock(Buffer.concat(currentBlock)))
-            currentBlock = []
-            currentBlockSize = 0
-          }
-          if (diffToSlice < chunk.byteLength) {
-            handleChunk(chunk.slice(diffToSlice))
-          }
-        }
-        handleChunk(_chunk)
-        callback()
-      },
-      flush (callback) {
-        blocks.push(hashBlock(Buffer.concat(currentBlock)))
-        currentBlock = []
-        callback()
-      }
-    })
-  )
-
-  return {
-    algorithm: ALGORITHM,
-    hash: fileHash.digest('hex'),
-    blockSize: BLOCK_SIZE,
-    blocks: blocks
-  }
-}
-
-module.exports = getFileIntegrity
diff --git a/node_modules/asar/lib/wrapped-fs.js b/node_modules/asar/lib/wrapped-fs.js
deleted file mode 100644
index 24f59d0..0000000
--- a/node_modules/asar/lib/wrapped-fs.js
+++ /dev/null
@@ -1,26 +0,0 @@
-'use strict'
-
-const fs = process.versions.electron ? require('original-fs') : require('fs')
-
-const promisifiedMethods = [
-  'lstat',
-  'mkdtemp',
-  'readFile',
-  'stat',
-  'writeFile'
-]
-
-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 })
-
-module.exports = promisified
diff --git a/node_modules/asar/package.json b/node_modules/asar/package.json
deleted file mode 100644
index 0ad7009..0000000
--- a/node_modules/asar/package.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
-  "name": "asar",
-  "description": "Creating Electron app packages",
-  "version": "3.2.0",
-  "main": "./lib/asar.js",
-  "types": "./lib/index.d.ts",
-  "bin": {
-    "asar": "./bin/asar.js"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "lib/index.d.ts"
-  ],
-  "engines": {
-    "node": ">=10.12.0"
-  },
-  "license": "MIT",
-  "homepage": "https://github.com/electron/asar",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/electron/asar.git"
-  },
-  "bugs": {
-    "url": "https://github.com/electron/asar/issues"
-  },
-  "scripts": {
-    "mocha": "xvfb-maybe electron-mocha --reporter spec && mocha --reporter spec",
-    "test": "npm run lint && npm run mocha",
-    "lint": "tsd && standard",
-    "standard": "standard",
-    "tsd": "tsd"
-  },
-  "standard": {
-    "env": {
-      "mocha": true
-    },
-    "globals": [
-      "BigInt"
-    ]
-  },
-  "tsd": {
-    "directory": "test"
-  },
-  "dependencies": {
-    "chromium-pickle-js": "^0.2.0",
-    "commander": "^5.0.0",
-    "glob": "^7.1.6",
-    "minimatch": "^3.0.4"
-  },
-  "optionalDependencies": {
-    "@types/glob": "^7.1.1"
-  },
-  "devDependencies": {
-    "@continuous-auth/semantic-release-npm": "^2.0.0",
-    "@semantic-release/changelog": "^5.0.0",
-    "electron": "^5.0.0",
-    "electron-mocha": "^8.2.1",
-    "lodash": "^4.17.15",
-    "mocha": "^7.1.1",
-    "rimraf": "^3.0.2",
-    "semantic-release": "^17.0.4",
-    "standard": "^14.3.3",
-    "tsd": "^0.11.0",
-    "xvfb-maybe": "^0.2.1"
-  }
-}