update

.pnpm-store/v10/files/03/5550b26ba77f2e901ae31a482367e5b8536d57239f27a65e6f11601737cd7b4a876d5ce8d10dbc1398049423b1834586a6c9a32d06671bf509378278c232e5

@@ -0,0 +1,4 @@
+'use strict';
+
+/** @type {import('./reflectApply')} */
+module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;

.pnpm-store/v10/files/03/74b342390025eea9cc8523869eaf4e72adc0eb458abb8766c18d98b6981da74002e5fda593dca5b661ab8b84320f5949d4955e91f720a039bf71dc1745afe5

@@ -0,0 +1,42 @@
+{
+  "name": "object-assign",
+  "version": "4.1.1",
+  "description": "ES2015 `Object.assign()` ponyfill",
+  "license": "MIT",
+  "repository": "sindresorhus/object-assign",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "xo && ava",
+    "bench": "matcha bench.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "object",
+    "assign",
+    "extend",
+    "properties",
+    "es2015",
+    "ecmascript",
+    "harmony",
+    "ponyfill",
+    "prollyfill",
+    "polyfill",
+    "shim",
+    "browser"
+  ],
+  "devDependencies": {
+    "ava": "^0.16.0",
+    "lodash": "^4.16.4",
+    "matcha": "^0.7.0",
+    "xo": "^0.16.0"
+  }
+}

.pnpm-store/v10/files/03/a97cdc4f6f1682d7484f7d9895ec2b3089eb81bfaf91c4bb5f747ead24f45bda07a723023b9baa00419c095db16d0445351defb4e288593c0d507bffe98639

@@ -0,0 +1,294 @@
+/**
+ * negotiator
+ * Copyright(c) 2012 Isaac Z. Schlueter
+ * Copyright(c) 2014 Federico Romero
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = preferredMediaTypes;
+module.exports.preferredMediaTypes = preferredMediaTypes;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+
+/**
+ * Parse the Accept header.
+ * @private
+ */
+
+function parseAccept(accept) {
+  var accepts = splitMediaTypes(accept);
+
+  for (var i = 0, j = 0; i < accepts.length; i++) {
+    var mediaType = parseMediaType(accepts[i].trim(), i);
+
+    if (mediaType) {
+      accepts[j++] = mediaType;
+    }
+  }
+
+  // trim accepts
+  accepts.length = j;
+
+  return accepts;
+}
+
+/**
+ * Parse a media type from the Accept header.
+ * @private
+ */
+
+function parseMediaType(str, i) {
+  var match = simpleMediaTypeRegExp.exec(str);
+  if (!match) return null;
+
+  var params = Object.create(null);
+  var q = 1;
+  var subtype = match[2];
+  var type = match[1];
+
+  if (match[3]) {
+    var kvps = splitParameters(match[3]).map(splitKeyValuePair);
+
+    for (var j = 0; j < kvps.length; j++) {
+      var pair = kvps[j];
+      var key = pair[0].toLowerCase();
+      var val = pair[1];
+
+      // get the value, unwrapping quotes
+      var value = val && val[0] === '"' && val[val.length - 1] === '"'
+        ? val.slice(1, -1)
+        : val;
+
+      if (key === 'q') {
+        q = parseFloat(value);
+        break;
+      }
+
+      // store parameter
+      params[key] = value;
+    }
+  }
+
+  return {
+    type: type,
+    subtype: subtype,
+    params: params,
+    q: q,
+    i: i
+  };
+}
+
+/**
+ * Get the priority of a media type.
+ * @private
+ */
+
+function getMediaTypePriority(type, accepted, index) {
+  var priority = {o: -1, q: 0, s: 0};
+
+  for (var i = 0; i < accepted.length; i++) {
+    var spec = specify(type, accepted[i], index);
+
+    if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+      priority = spec;
+    }
+  }
+
+  return priority;
+}
+
+/**
+ * Get the specificity of the media type.
+ * @private
+ */
+
+function specify(type, spec, index) {
+  var p = parseMediaType(type);
+  var s = 0;
+
+  if (!p) {
+    return null;
+  }
+
+  if(spec.type.toLowerCase() == p.type.toLowerCase()) {
+    s |= 4
+  } else if(spec.type != '*') {
+    return null;
+  }
+
+  if(spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {
+    s |= 2
+  } else if(spec.subtype != '*') {
+    return null;
+  }
+
+  var keys = Object.keys(spec.params);
+  if (keys.length > 0) {
+    if (keys.every(function (k) {
+      return spec.params[k] == '*' || (spec.params[k] || '').toLowerCase() == (p.params[k] || '').toLowerCase();
+    })) {
+      s |= 1
+    } else {
+      return null
+    }
+  }
+
+  return {
+    i: index,
+    o: spec.i,
+    q: spec.q,
+    s: s,
+  }
+}
+
+/**
+ * Get the preferred media types from an Accept header.
+ * @public
+ */
+
+function preferredMediaTypes(accept, provided) {
+  // RFC 2616 sec 14.2: no header = */*
+  var accepts = parseAccept(accept === undefined ? '*/*' : accept || '');
+
+  if (!provided) {
+    // sorted list of all types
+    return accepts
+      .filter(isQuality)
+      .sort(compareSpecs)
+      .map(getFullType);
+  }
+
+  var priorities = provided.map(function getPriority(type, index) {
+    return getMediaTypePriority(type, accepts, index);
+  });
+
+  // sorted list of accepted types
+  return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
+    return provided[priorities.indexOf(priority)];
+  });
+}
+
+/**
+ * Compare two specs.
+ * @private
+ */
+
+function compareSpecs(a, b) {
+  return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
+}
+
+/**
+ * Get full type string.
+ * @private
+ */
+
+function getFullType(spec) {
+  return spec.type + '/' + spec.subtype;
+}
+
+/**
+ * Check if a spec has any quality.
+ * @private
+ */
+
+function isQuality(spec) {
+  return spec.q > 0;
+}
+
+/**
+ * Count the number of quotes in a string.
+ * @private
+ */
+
+function quoteCount(string) {
+  var count = 0;
+  var index = 0;
+
+  while ((index = string.indexOf('"', index)) !== -1) {
+    count++;
+    index++;
+  }
+
+  return count;
+}
+
+/**
+ * Split a key value pair.
+ * @private
+ */
+
+function splitKeyValuePair(str) {
+  var index = str.indexOf('=');
+  var key;
+  var val;
+
+  if (index === -1) {
+    key = str;
+  } else {
+    key = str.slice(0, index);
+    val = str.slice(index + 1);
+  }
+
+  return [key, val];
+}
+
+/**
+ * Split an Accept header into media types.
+ * @private
+ */
+
+function splitMediaTypes(accept) {
+  var accepts = accept.split(',');
+
+  for (var i = 1, j = 0; i < accepts.length; i++) {
+    if (quoteCount(accepts[j]) % 2 == 0) {
+      accepts[++j] = accepts[i];
+    } else {
+      accepts[j] += ',' + accepts[i];
+    }
+  }
+
+  // trim accepts
+  accepts.length = j + 1;
+
+  return accepts;
+}
+
+/**
+ * Split a string of parameters.
+ * @private
+ */
+
+function splitParameters(str) {
+  var parameters = str.split(';');
+
+  for (var i = 1, j = 0; i < parameters.length; i++) {
+    if (quoteCount(parameters[j]) % 2 == 0) {
+      parameters[++j] = parameters[i];
+    } else {
+      parameters[j] += ';' + parameters[i];
+    }
+  }
+
+  // trim parameters
+  parameters.length = j + 1;
+
+  for (var i = 0; i < parameters.length; i++) {
+    parameters[i] = parameters[i].trim();
+  }
+
+  return parameters;
+}

.pnpm-store/v10/files/03/c97f75dcd1aef0717bec9915f7c92d5eebe14258db60189bf79362f1ad9ff053c0309a572007db17384bfee4b8b0f2c17989bdb04ac106bf18314b8feff8c3

@@ -0,0 +1,40 @@
+{
+	"name": "binary-extensions",
+	"version": "2.3.0",
+	"description": "List of binary file extensions",
+	"license": "MIT",
+	"repository": "sindresorhus/binary-extensions",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"binary-extensions.json",
+		"binary-extensions.json.d.ts"
+	],
+	"keywords": [
+		"binary",
+		"extensions",
+		"extension",
+		"file",
+		"json",
+		"list",
+		"array"
+	],
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
+	}
+}

.pnpm-store/v10/files/03/ff2bc61fb7ea5e5692c37340fe72d956f8865128c6593567b9f609e3b641e7c9db2e0c03310d4f42fc5d448c22644869c592b4420e4600cd572d8893343a51

@@ -0,0 +1,287 @@
+const minimatch = require('minimatch');
+const path = require('path');
+const fs = require('fs');
+const debug = require('debug')('nodemon:match');
+const utils = require('../utils');
+
+module.exports = match;
+module.exports.rulesToMonitor = rulesToMonitor;
+
+function rulesToMonitor(watch, ignore, config) {
+  var monitor = [];
+
+  if (!Array.isArray(ignore)) {
+    if (ignore) {
+      ignore = [ignore];
+    } else {
+      ignore = [];
+    }
+  }
+
+  if (!Array.isArray(watch)) {
+    if (watch) {
+      watch = [watch];
+    } else {
+      watch = [];
+    }
+  }
+
+  if (watch && watch.length) {
+    monitor = utils.clone(watch);
+  }
+
+  if (ignore) {
+    [].push.apply(
+      monitor,
+      (ignore || []).map(function (rule) {
+        return '!' + rule;
+      })
+    );
+  }
+
+  var cwd = process.cwd();
+
+  // next check if the monitored paths are actual directories
+  // or just patterns - and expand the rule to include *.*
+  monitor = monitor.map(function (rule) {
+    var not = rule.slice(0, 1) === '!';
+
+    if (not) {
+      rule = rule.slice(1);
+    }
+
+    if (rule === '.' || rule === '.*') {
+      rule = '*.*';
+    }
+
+    var dir = path.resolve(cwd, rule);
+
+    try {
+      var stat = fs.statSync(dir);
+      if (stat.isDirectory()) {
+        rule = dir;
+        if (rule.slice(-1) !== '/') {
+          rule += '/';
+        }
+        rule += '**/*';
+
+        // `!not` ... sorry.
+        if (!not) {
+          config.dirs.push(dir);
+        }
+      } else {
+        // ensures we end up in the check that tries to get a base directory
+        // and then adds it to the watch list
+        throw new Error();
+      }
+    } catch (e) {
+      var base = tryBaseDir(dir);
+      if (!not && base) {
+        if (config.dirs.indexOf(base) === -1) {
+          config.dirs.push(base);
+        }
+      }
+    }
+
+    if (rule.slice(-1) === '/') {
+      // just slap on a * anyway
+      rule += '*';
+    }
+
+    // if the url ends with * but not **/* and not *.*
+    // then convert to **/* - somehow it was missed :-\
+    if (
+      rule.slice(-4) !== '**/*' &&
+      rule.slice(-1) === '*' &&
+      rule.indexOf('*.') === -1
+    ) {
+      if (rule.slice(-2) !== '**') {
+        rule += '*/*';
+      }
+    }
+
+    return (not ? '!' : '') + rule;
+  });
+
+  return monitor;
+}
+
+function tryBaseDir(dir) {
+  var stat;
+  if (/[?*\{\[]+/.test(dir)) {
+    // if this is pattern, then try to find the base
+    try {
+      var base = path.dirname(dir.replace(/([?*\{\[]+.*$)/, 'foo'));
+      stat = fs.statSync(base);
+      if (stat.isDirectory()) {
+        return base;
+      }
+    } catch (error) {
+      // console.log(error);
+    }
+  } else {
+    try {
+      stat = fs.statSync(dir);
+      // if this path is actually a single file that exists, then just monitor
+      // that, *specifically*.
+      if (stat.isFile() || stat.isDirectory()) {
+        return dir;
+      }
+    } catch (e) {}
+  }
+
+  return false;
+}
+
+function match(files, monitor, ext) {
+  // sort the rules by highest specificity (based on number of slashes)
+  // ignore rules (!) get sorted highest as they take precedent
+  const cwd = process.cwd();
+  var rules = monitor
+    .sort(function (a, b) {
+      var r = b.split(path.sep).length - a.split(path.sep).length;
+      var aIsIgnore = a.slice(0, 1) === '!';
+      var bIsIgnore = b.slice(0, 1) === '!';
+
+      if (aIsIgnore || bIsIgnore) {
+        if (aIsIgnore) {
+          return -1;
+        }
+
+        return 1;
+      }
+
+      if (r === 0) {
+        return b.length - a.length;
+      }
+      return r;
+    })
+    .map(function (s) {
+      var prefix = s.slice(0, 1);
+
+      if (prefix === '!') {
+        if (s.indexOf('!' + cwd) === 0) {
+          return s;
+        }
+
+        // if it starts with a period, then let's get the relative path
+        if (s.indexOf('!.') === 0) {
+          return '!' + path.resolve(cwd, s.substring(1));
+        }
+
+        return '!**' + (prefix !== path.sep ? path.sep : '') + s.slice(1);
+      }
+
+      // if it starts with a period, then let's get the relative path
+      if (s.indexOf('.') === 0) {
+        return path.resolve(cwd, s);
+      }
+
+      if (s.indexOf(cwd) === 0) {
+        return s;
+      }
+
+      return '**' + (prefix !== path.sep ? path.sep : '') + s;
+    });
+
+  debug('rules', rules);
+
+  var good = [];
+  var whitelist = []; // files that we won't check against the extension
+  var ignored = 0;
+  var watched = 0;
+  var usedRules = [];
+  var minimatchOpts = {
+    dot: true,
+  };
+
+  // enable case-insensitivity on Windows
+  if (utils.isWindows) {
+    minimatchOpts.nocase = true;
+  }
+
+  files.forEach(function (file) {
+    file = path.resolve(cwd, file);
+
+    var matched = false;
+    for (var i = 0; i < rules.length; i++) {
+      if (rules[i].slice(0, 1) === '!') {
+        if (!minimatch(file, rules[i], minimatchOpts)) {
+          debug('ignored', file, 'rule:', rules[i]);
+          ignored++;
+          matched = true;
+          break;
+        }
+      } else {
+        debug('matched', file, 'rule:', rules[i]);
+        if (minimatch(file, rules[i], minimatchOpts)) {
+          watched++;
+
+          // don't repeat the output if a rule is matched
+          if (usedRules.indexOf(rules[i]) === -1) {
+            usedRules.push(rules[i]);
+            utils.log.detail('matched rule: ' + rules[i]);
+          }
+
+          // if the rule doesn't match the WATCH EVERYTHING
+          // but *does* match a rule that ends with *.*, then
+          // white list it - in that we don't run it through
+          // the extension check too.
+          if (
+            rules[i] !== '**' + path.sep + '*.*' &&
+            rules[i].slice(-3) === '*.*'
+          ) {
+            whitelist.push(file);
+          } else if (path.basename(file) === path.basename(rules[i])) {
+            // if the file matches the actual rule, then it's put on whitelist
+            whitelist.push(file);
+          } else {
+            good.push(file);
+          }
+          matched = true;
+        } else {
+          // utils.log.detail('no match: ' + rules[i], file);
+        }
+      }
+    }
+    if (!matched) {
+      ignored++;
+    }
+  });
+
+  // finally check the good files against the extensions that we're monitoring
+  if (ext) {
+    if (ext.indexOf(',') === -1) {
+      ext = '**/*.' + ext;
+    } else {
+      ext = '**/*.{' + ext + '}';
+    }
+
+    good = good.filter(function (file) {
+      // only compare the filename to the extension test
+      return minimatch(path.basename(file), ext, minimatchOpts);
+    });
+    debug('good (filtered by ext)', good);
+  } else {
+    // else assume *.*
+    debug('good', good);
+  }
+
+  if (whitelist.length) debug('whitelist', whitelist);
+
+  var result = good.concat(whitelist);
+
+  if (utils.isWindows) {
+    // fix for windows testing - I *think* this is okay to do
+    result = result.map(function (file) {
+      return file.slice(0, 1).toLowerCase() + file.slice(1);
+    });
+  }
+
+  return {
+    result: result,
+    ignored: ignored,
+    watched: watched,
+    total: files.length,
+  };
+}