chore: disable delete confirmation in VS Code explorer

Disable the confirmation dialog when deleting files in the VS Code explorer to streamline the development workflow and reduce friction during file management operations.

website/node_modules/.bin/ejs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let path = require('path');
+
+let { Parser } = require('../lib/cjs/parseargs');
+
+let ejs = require('../lib/cjs/ejs');
+let { hyphenToCamel } = require('../lib/cjs/utils');
+let fs = require('fs');
+let args = process.argv.slice(2);
+let usage = fs.readFileSync(`${__dirname}/../usage.txt`).toString();
+
+function die(msg) {
+  console.log(msg);
+  process.stdout.write('', function () {
+    process.stderr.write('', function () {
+      process.exit();
+    });
+  });
+}
+
+const CLI_OPTS = [
+  { full: 'output-file',
+    abbr: 'o',
+    expectValue: true,
+  },
+  { full: 'data-file',
+    abbr: 'f',
+    expectValue: true,
+  },
+  { full: 'data-input',
+    abbr: 'i',
+    expectValue: true,
+  },
+  { full: 'delimiter',
+    abbr: 'm',
+    expectValue: true,
+    passThrough: true,
+  },
+  { full: 'open-delimiter',
+    abbr: 'p',
+    expectValue: true,
+    passThrough: true,
+  },
+  { full: 'close-delimiter',
+    abbr: 'c',
+    expectValue: true,
+    passThrough: true,
+  },
+  { full: 'strict',
+    abbr: 's',
+    expectValue: false,
+    allowValue: false,
+    passThrough: true,
+  },
+  { full: 'no-with',
+    abbr: 'n',
+    expectValue: false,
+    allowValue: false,
+  },
+  { full: 'locals-name',
+    abbr: 'l',
+    expectValue: true,
+    passThrough: true,
+  },
+  { full: 'rm-whitespace',
+    abbr: 'w',
+    expectValue: false,
+    allowValue: false,
+    passThrough: true,
+  },
+  { full: 'debug',
+    abbr: 'd',
+    expectValue: false,
+    allowValue: false,
+    passThrough: true,
+  },
+  { full: 'help',
+    abbr: 'h',
+    passThrough: true,
+  },
+  { full: 'version',
+    abbr: 'V',
+    passThrough: true,
+  },
+  // Alias lowercase v
+  { full: 'version',
+    abbr: 'v',
+    passThrough: true,
+  },
+];
+
+let preempts = {
+  version: function () {
+    die(ejs.VERSION);
+  },
+  help: function () {
+    die(usage);
+  }
+};
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    stdin += chunk;
+  }
+});
+
+function run() {
+
+  let parser = new Parser(CLI_OPTS);
+  let result = parser.parse(args);
+
+  let templatePath = result.taskNames[0];
+  let pVals = result.envVars;
+  let pOpts = {};
+
+  for (let p in result.opts) {
+    let name = hyphenToCamel(p);
+    pOpts[name] = result.opts[p];
+  }
+
+  let opts = {};
+  let vals = {};
+
+  // Same-named 'passthrough' opts
+  CLI_OPTS.forEach((opt) => {
+    let optName = hyphenToCamel(opt.full);
+    if (opt.passThrough && typeof pOpts[optName] != 'undefined') {
+      opts[optName] = pOpts[optName];
+    }
+  });
+
+  // Bail out for help/version
+  for (let p in opts) {
+    if (preempts[p]) {
+      return preempts[p]();
+    }
+  }
+
+  // Ensure there's a template to render
+  if (!templatePath) {
+    throw new Error('Please provide a template path. (Run ejs -h for help)');
+  }
+
+  if (opts.strict) {
+    pOpts.noWith = true;
+  }
+  if (pOpts.noWith) {
+    opts._with = false;
+  }
+
+  // Grab and parse any input data, in order of precedence:
+  // 1. Stdin
+  // 2. CLI arg via -i
+  // 3. Data file via -f
+  // Any individual vals passed at the end (e.g., foo=bar) will override
+  // any vals previously set
+  let input;
+  let err = new Error('Please do not pass data multiple ways. Pick one of stdin, -f, or -i.');
+  if (stdin) {
+    input = stdin;
+  }
+  else if (pOpts.dataInput) {
+    if (input) {
+      throw err;
+    }
+    input = decodeURIComponent(pOpts.dataInput);
+  }
+  else if (pOpts.dataFile) {
+    if (input) {
+      throw err;
+    }
+    input = fs.readFileSync(pOpts.dataFile).toString();
+  }
+
+  if (input) {
+    vals = JSON.parse(input);
+  }
+
+  // Override / set any individual values passed from the command line
+  for (let p in pVals) {
+    vals[p] = pVals[p];
+  }
+
+  opts.filename = path.resolve(process.cwd(), templatePath);
+  let template = fs.readFileSync(opts.filename).toString();
+  let output = ejs.render(template, vals, opts);
+  if (pOpts.outputFile) {
+    fs.writeFileSync(pOpts.outputFile, output);
+  }
+  else {
+    process.stdout.write(output);
+  }
+  process.exit();
+}
+
+// Defer execution so that stdin can be read if necessary
+setImmediate(run);

website/node_modules/.bin/mime

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+var mime = require('./mime.js');
+var file = process.argv[2];
+var type = mime.lookup(file);
+
+process.stdout.write(type + '\n');
+

website/node_modules/.bin/nodemon

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const cli = require('../lib/cli');
+const nodemon = require('../lib/');
+const options = cli.parse(process.argv);
+
+nodemon(options);
+
+const fs = require('fs');
+
+// checks for available update and returns an instance
+const pkg = JSON.parse(fs.readFileSync(__dirname + '/../package.json'));
+
+if (pkg.version.indexOf('0.0.0') !== 0 && options.noUpdateNotifier !== true) {
+  require('simple-update-notifier')({ pkg });
+}

website/node_modules/.bin/nodetouch

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+const touch = require("../index.js")
+
+const usage = code => {
+  console[code ? 'error' : 'log'](
+    'usage:\n' +
+    'touch [-acfm] [-r file] [-t [[CC]YY]MMDDhhmm[.SS]] file ...'
+  )
+  process.exit(code)
+}
+
+const singleFlags = {
+  a: 'atime',
+  m: 'mtime',
+  c: 'nocreate',
+  f: 'force'
+}
+
+const singleOpts = {
+  r: 'ref',
+  t: 'time'
+}
+
+const files = []
+const args = process.argv.slice(2)
+const options = {}
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i]
+  if (!arg.match(/^-/)) {
+    files.push(arg)
+    continue
+  }
+
+  // expand shorthands
+  if (arg.charAt(1) !== '-') {
+    const expand = []
+    for (let f = 1; f < arg.length; f++) {
+      const fc = arg.charAt(f)
+      const sf = singleFlags[fc]
+      const so = singleOpts[fc]
+      if (sf)
+        expand.push('--' + sf)
+      else if (so) {
+        const soslice = arg.slice(f + 1)
+        const soval = soslice.charAt(0) === '=' ? soslice : '=' + soslice
+        expand.push('--' + so + soval)
+        f = arg.length
+      } else if (arg !== '-' + fc)
+        expand.push('-' + fc)
+    }
+    if (expand.length) {
+      args.splice.apply(args, [i, 1].concat(expand))
+      i--
+      continue
+    }
+  }
+
+  const argsplit = arg.split('=')
+  const key = argsplit.shift().replace(/^\-\-/, '')
+  const val = argsplit.length ? argsplit.join('=') : null
+
+  switch (key) {
+    case 'time':
+      const timestr = val || args[++i]
+      // [-t [[CC]YY]MMDDhhmm[.SS]]
+      const parsedtime = timestr.match(
+        /^(([0-9]{2})?([0-9]{2}))?([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})(\.([0-9]{2}))?$/
+      )
+      if (!parsedtime) {
+        console.error('touch: out of range or illegal ' +
+                      'time specification: ' +
+                      '[[CC]YY]MMDDhhmm[.SS]')
+        process.exit(1)
+      } else {
+        const y = +parsedtime[1]
+        const year = parsedtime[2] ? y
+          : y <= 68 ? 2000 + y
+          : 1900 + y
+
+        const MM = +parsedtime[4] - 1
+        const dd = +parsedtime[5]
+        const hh = +parsedtime[6]
+        const mm = +parsedtime[7]
+        const ss = +parsedtime[8]
+
+        options.time = new Date(Date.UTC(year, MM, dd, hh, mm, ss))
+      }
+      continue
+
+    case 'ref':
+      options.ref = val || args[++i]
+      continue
+
+    case 'mtime':
+    case 'nocreate':
+    case 'atime':
+    case 'force':
+      options[key] = true
+      continue
+
+    default:
+      console.error('touch: illegal option -- ' + arg)
+      usage(1)
+  }
+}
+
+if (!files.length)
+  usage()
+
+process.exitCode = 0
+Promise.all(files.map(f => touch(f, options)))
+  .catch(er => process.exitCode = 1)

website/node_modules/.bin/semver

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+'use strict'
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+let identifierBase
+
+const semver = require('../')
+const parseOptions = require('../internal/parse-options')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+          case 'release':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-n':
+        identifierBase = argv.shift()
+        if (identifierBase === 'false') {
+          identifierBase = false
+        }
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = parseOptions({ loose, includePrerelease, rtl })
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v, options)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  versions
+    .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
+    .map(v => semver.clean(v, options))
+    .map(v => inc ? semver.inc(v, inc, options, identifier, identifierBase) : v)
+    .forEach(v => console.log(v))
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, prerelease, or release.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+-n <base>
+        Base number to be used for the prerelease identifier.
+        Can be either 0 or 1, or false to omit the number altogether.
+        Defaults to 0.
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()