build(deps-dev): bump vite from 4.4.9 to 5.0.5 #1269
Closed
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=60&v=4){kind=small}
Bumps [vite](https://github.com/vitejs/vite/tree/HEAD/packages/vite) from 4.4.9 to 5.0.5. - [Release notes](https://github.com/vitejs/vite/releases) - [Changelog](https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md) - [Commits](https://github.com/vitejs/vite/commits/v5.0.5/packages/vite) --- updated-dependencies: - dependency-name: vite dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
bot
added
dependencies
Diff between vite 4.4.9 and 5.0.5diff --git a/index.cjs b/index.cjs
index v4.4.9..v5.0.5 100644
--- a/index.cjs
+++ b/index.cjs
@@ -1,4 +1,6 @@
/* eslint-disable no-restricted-globals */
+warnCjsUsage()
+
// type utils
module.exports.defineConfig = (config) => config
@@ -24,11 +26,12 @@
})
-// some sync functions are marked not supported due to their complexity and uncommon usage
-const unsupportedCJS = ['resolvePackageEntry', 'resolvePackageData']
-unsupportedCJS.forEach((name) => {
- module.exports[name] = () => {
- throw new Error(
- `"${name}" is not supported in CJS build of Vite 4.\nPlease use ESM or dynamic imports \`const { ${name} } = await import('vite')\`.`,
- )
- }
-})
+function warnCjsUsage() {
+ if (process.env.VITE_CJS_IGNORE_WARNING) return
+ const yellow = (str) => `\u001b[33m${str}\u001b[39m`
+ const log = process.env.VITE_CJS_TRACE ? console.trace : console.warn
+ log(
+ yellow(
+ `The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.`,
+ ),
+ )
+}
diff --git a/dist/node-cjs/publicUtils.cjs b/dist/node-cjs/publicUtils.cjs
index v4.4.9..v5.0.5 100644
--- a/dist/node-cjs/publicUtils.cjs
+++ b/dist/node-cjs/publicUtils.cjs
@@ -16,5 +16,6 @@
var require$$2 = require('os');
-const { version: version$2 } = JSON.parse(fs$1.readFileSync(new URL('../../package.json', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString());
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const { version: version$2 } = JSON.parse(fs$1.readFileSync(new URL('../../package.json', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString());
const VERSION = version$2;
/**
@@ -24,17 +25,96 @@
const VITE_PACKAGE_DIR = path$3.resolve(
// import.meta.url is `dist/node/constants.js` after bundle
-node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))), '../../..');
+node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))), '../../..');
const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/client.mjs');
path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/env.mjs');
path$3.dirname(CLIENT_ENTRY);
-const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar$1 = new Uint8Array(64); // 64 possible chars.
-const charToInt$1 = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars$1.length; i++) {
- const c = chars$1.charCodeAt(i);
- intToChar$1[i] = c;
- charToInt$1[c] = i;
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+ const c = chars.charCodeAt(i);
+ intToChar[i] = c;
+ charToInt[c] = i;
}
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+ ? /* #__PURE__ */ new TextDecoder()
+ : typeof Buffer !== 'undefined'
+ ? {
+ decode(buf) {
+ const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+ return out.toString();
+ },
+ }
+ : {
+ decode(buf) {
+ let out = '';
+ for (let i = 0; i < buf.length; i++) {
+ out += String.fromCharCode(buf[i]);
+ }
+ return out;
+ },
+ };
+function encode(decoded) {
+ const state = new Int32Array(5);
+ const bufLength = 1024 * 16;
+ const subLength = bufLength - 36;
+ const buf = new Uint8Array(bufLength);
+ const sub = buf.subarray(0, subLength);
+ let pos = 0;
+ let out = '';
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ if (i > 0) {
+ if (pos === bufLength) {
+ out += td.decode(buf);
+ pos = 0;
+ }
+ buf[pos++] = semicolon;
+ }
+ if (line.length === 0)
+ continue;
+ state[0] = 0;
+ for (let j = 0; j < line.length; j++) {
+ const segment = line[j];
+ // We can push up to 5 ints, each int can take at most 7 chars, and we
+ // may push a comma.
+ if (pos > subLength) {
+ out += td.decode(sub);
+ buf.copyWithin(0, subLength, pos);
+ pos -= subLength;
+ }
+ if (j > 0)
+ buf[pos++] = comma;
+ pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+ if (segment.length === 1)
+ continue;
+ pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
+ pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
+ pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+ if (segment.length === 4)
+ continue;
+ pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+ }
+ }
+ return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+ const next = segment[j];
+ let num = next - state[j];
+ state[j] = next;
+ num = num < 0 ? (-num << 1) | 1 : num << 1;
+ do {
+ let clamped = num & 0b011111;
+ num >>>= 5;
+ if (num > 0)
+ clamped |= 0b100000;
+ buf[pos++] = intToChar[clamped];
+ } while (num > 0);
+ return pos;
+}
// Matches the scheme of a URL, eg "http://"
@@ -50,13 +130,4 @@
})(UrlType || (UrlType = {}));
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars.length; i++) {
- const c = chars.charCodeAt(i);
- intToChar[i] = c;
- charToInt[c] = i;
-}
-
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -129,5 +200,5 @@
var src = {exports: {}};
-var browser$1 = {exports: {}};
+var node = {exports: {}};
/**
@@ -584,4 +655,279 @@
}
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+ if (hasRequiredNode) return node.exports;
+ hasRequiredNode = 1;
+ (function (module, exports) {
+ const tty = require$$0;
+ const util = require$$1;
+
+ /**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+ exports.init = init;
+ exports.log = log;
+ exports.formatArgs = formatArgs;
+ exports.save = save;
+ exports.load = load;
+ exports.useColors = useColors;
+ exports.destroy = util.deprecate(
+ () => {},
+ 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+ );
+
+ /**
+ * Colors.
+ */
+
+ exports.colors = [6, 2, 3, 4, 5, 1];
+
+ try {
+ // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+ // eslint-disable-next-line import/no-extraneous-dependencies
+ const supportsColor = require('supports-color');
+
+ if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+ exports.colors = [
+ 20,
+ 21,
+ 26,
+ 27,
+ 32,
+ 33,
+ 38,
+ 39,
+ 40,
+ 41,
+ 42,
+ 43,
+ 44,
+ 45,
+ 56,
+ 57,
+ 62,
+ 63,
+ 68,
+ 69,
+ 74,
+ 75,
+ 76,
+ 77,
+ 78,
+ 79,
+ 80,
+ 81,
+ 92,
+ 93,
+ 98,
+ 99,
+ 112,
+ 113,
+ 128,
+ 129,
+ 134,
+ 135,
+ 148,
+ 149,
+ 160,
+ 161,
+ 162,
+ 163,
+ 164,
+ 165,
+ 166,
+ 167,
+ 168,
+ 169,
+ 170,
+ 171,
+ 172,
+ 173,
+ 178,
+ 179,
+ 184,
+ 185,
+ 196,
+ 197,
+ 198,
+ 199,
+ 200,
+ 201,
+ 202,
+ 203,
+ 204,
+ 205,
+ 206,
+ 207,
+ 208,
+ 209,
+ 214,
+ 215,
+ 220,
+ 221
+ ];
+ }
+ } catch (error) {
+ // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+ }
+
+ /**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+ exports.inspectOpts = Object.keys(process.env).filter(key => {
+ return /^debug_/i.test(key);
+ }).reduce((obj, key) => {
+ // Camel-case
+ const prop = key
+ .substring(6)
+ .toLowerCase()
+ .replace(/_([a-z])/g, (_, k) => {
+ return k.toUpperCase();
+ });
+
+ // Coerce string value into JS value
+ let val = process.env[key];
+ if (/^(yes|on|true|enabled)$/i.test(val)) {
+ val = true;
+ } else if (/^(no|off|false|disabled)$/i.test(val)) {
+ val = false;
+ } else if (val === 'null') {
+ val = null;
+ } else {
+ val = Number(val);
+ }
+
+ obj[prop] = val;
+ return obj;
+ }, {});
+
+ /**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+ function useColors() {
+ return 'colors' in exports.inspectOpts ?
+ Boolean(exports.inspectOpts.colors) :
+ tty.isatty(process.stderr.fd);
+ }
+
+ /**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+ function formatArgs(args) {
+ const {namespace: name, useColors} = this;
+
+ if (useColors) {
+ const c = this.color;
+ const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+ const prefix = ` ${colorCode};1m${name} \u001B[0m`;
+
+ args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+ args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+ } else {
+ args[0] = getDate() + name + ' ' + args[0];
+ }
+ }
+
+ function getDate() {
+ if (exports.inspectOpts.hideDate) {
+ return '';
+ }
+ return new Date().toISOString() + ' ';
+ }
+
+ /**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
+
+ function log(...args) {
+ return process.stderr.write(util.format(...args) + '\n');
+ }
+
+ /**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+ function save(namespaces) {
+ if (namespaces) {
+ process.env.DEBUG = namespaces;
+ } else {
+ // If you set a process.env field to null or undefined, it gets cast to the
+ // string 'null' or 'undefined'. Just delete instead.
+ delete process.env.DEBUG;
+ }
+ }
+
+ /**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+ function load() {
+ return process.env.DEBUG;
+ }
+
+ /**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+ function init(debug) {
+ debug.inspectOpts = {};
+
+ const keys = Object.keys(exports.inspectOpts);
+ for (let i = 0; i < keys.length; i++) {
+ debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+ }
+ }
+
+ module.exports = requireCommon()(exports);
+
+ const {formatters} = module.exports;
+
+ /**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+ formatters.o = function (v) {
+ this.inspectOpts.colors = this.useColors;
+ return util.inspect(v, this.inspectOpts)
+ .split('\n')
+ .map(str => str.trim())
+ .join(' ');
+ };
+
+ /**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+ formatters.O = function (v) {
+ this.inspectOpts.colors = this.useColors;
+ return util.inspect(v, this.inspectOpts);
+ };
+ } (node, node.exports));
+ return node.exports;
+}
+
+var browser$1 = {exports: {}};
+
/* eslint-env browser */
@@ -863,280 +1209,5 @@
}
-var node = {exports: {}};
-
/**
- * Module dependencies.
- */
-
-var hasRequiredNode;
-
-function requireNode () {
- if (hasRequiredNode) return node.exports;
- hasRequiredNode = 1;
- (function (module, exports) {
- const tty = require$$0;
- const util = require$$1;
-
- /**
- * This is the Node.js implementation of `debug()`.
- */
-
- exports.init = init;
- exports.log = log;
- exports.formatArgs = formatArgs;
- exports.save = save;
- exports.load = load;
- exports.useColors = useColors;
- exports.destroy = util.deprecate(
- () => {},
- 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
- );
-
- /**
- * Colors.
- */
-
- exports.colors = [6, 2, 3, 4, 5, 1];
-
- try {
- // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
- // eslint-disable-next-line import/no-extraneous-dependencies
- const supportsColor = require('supports-color');
-
- if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
- exports.colors = [
- 20,
- 21,
- 26,
- 27,
- 32,
- 33,
- 38,
- 39,
- 40,
- 41,
- 42,
- 43,
- 44,
- 45,
- 56,
- 57,
- 62,
- 63,
- 68,
- 69,
- 74,
- 75,
- 76,
- 77,
- 78,
- 79,
- 80,
- 81,
- 92,
- 93,
- 98,
- 99,
- 112,
- 113,
- 128,
- 129,
- 134,
- 135,
- 148,
- 149,
- 160,
- 161,
- 162,
- 163,
- 164,
- 165,
- 166,
- 167,
- 168,
- 169,
- 170,
- 171,
- 172,
- 173,
- 178,
- 179,
- 184,
- 185,
- 196,
- 197,
- 198,
- 199,
- 200,
- 201,
- 202,
- 203,
- 204,
- 205,
- 206,
- 207,
- 208,
- 209,
- 214,
- 215,
- 220,
- 221
- ];
- }
- } catch (error) {
- // Swallow - we only care if `supports-color` is available; it doesn't have to be.
- }
-
- /**
- * Build up the default `inspectOpts` object from the environment variables.
- *
- * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
- */
-
- exports.inspectOpts = Object.keys(process.env).filter(key => {
- return /^debug_/i.test(key);
- }).reduce((obj, key) => {
- // Camel-case
- const prop = key
- .substring(6)
- .toLowerCase()
- .replace(/_([a-z])/g, (_, k) => {
- return k.toUpperCase();
- });
-
- // Coerce string value into JS value
- let val = process.env[key];
- if (/^(yes|on|true|enabled)$/i.test(val)) {
- val = true;
- } else if (/^(no|off|false|disabled)$/i.test(val)) {
- val = false;
- } else if (val === 'null') {
- val = null;
- } else {
- val = Number(val);
- }
-
- obj[prop] = val;
- return obj;
- }, {});
-
- /**
- * Is stdout a TTY? Colored output is enabled when `true`.
- */
-
- function useColors() {
- return 'colors' in exports.inspectOpts ?
- Boolean(exports.inspectOpts.colors) :
- tty.isatty(process.stderr.fd);
- }
-
- /**
- * Adds ANSI color escape codes if enabled.
- *
- * @api public
- */
-
- function formatArgs(args) {
- const {namespace: name, useColors} = this;
-
- if (useColors) {
- const c = this.color;
- const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
- const prefix = ` ${colorCode};1m${name} \u001B[0m`;
-
- args[0] = prefix + args[0].split('\n').join('\n' + prefix);
- args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
- } else {
- args[0] = getDate() + name + ' ' + args[0];
- }
- }
-
- function getDate() {
- if (exports.inspectOpts.hideDate) {
- return '';
- }
- return new Date().toISOString() + ' ';
- }
-
- /**
- * Invokes `util.format()` with the specified arguments and writes to stderr.
- */
-
- function log(...args) {
- return process.stderr.write(util.format(...args) + '\n');
- }
-
- /**
- * Save `namespaces`.
- *
- * @param {String} namespaces
- * @api private
- */
- function save(namespaces) {
- if (namespaces) {
- process.env.DEBUG = namespaces;
- } else {
- // If you set a process.env field to null or undefined, it gets cast to the
- // string 'null' or 'undefined'. Just delete instead.
- delete process.env.DEBUG;
- }
- }
-
- /**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
-
- function load() {
- return process.env.DEBUG;
- }
-
- /**
- * Init logic for `debug` instances.
- *
- * Create a new `inspectOpts` object in case `useColors` is set
- * differently for a particular `debug` instance.
- */
-
- function init(debug) {
- debug.inspectOpts = {};
-
- const keys = Object.keys(exports.inspectOpts);
- for (let i = 0; i < keys.length; i++) {
- debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
- }
- }
-
- module.exports = requireCommon()(exports);
-
- const {formatters} = module.exports;
-
- /**
- * Map %o to `util.inspect()`, all on a single line.
- */
-
- formatters.o = function (v) {
- this.inspectOpts.colors = this.useColors;
- return util.inspect(v, this.inspectOpts)
- .split('\n')
- .map(str => str.trim())
- .join(' ');
- };
-
- /**
- * Map %O to `util.inspect()`, allowing multiple lines if needed.
- */
-
- formatters.O = function (v) {
- this.inspectOpts.colors = this.useColors;
- return util.inspect(v, this.inspectOpts);
- };
- } (node, node.exports));
- return node.exports;
-}
-
-/**
* Detect Electron renderer / nwjs process, which is node, but we should
* treat as a browser.
@@ -1150,5 +1221,5 @@
var srcExports = src.exports;
-var debug$1 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+var debug$2 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
var utils$3 = {};
@@ -2876,5 +2947,5 @@
const utils = utils$3;
const constants = constants$2;
-const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
+const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
/**
@@ -2913,5 +2984,5 @@
}
- const isState = isObject$1(glob) && glob.tokens && glob.input;
+ const isState = isObject$2(glob) && glob.tokens && glob.input;
if (glob === '' || (typeof glob !== 'string' && !isState)) {
@@ -3233,5 +3304,5 @@
function getMatcherString(id, resolutionBase) {
- if (resolutionBase === false || require$$0$1.isAbsolute(id) || id.startsWith('*')) {
+ if (resolutionBase === false || require$$0$1.isAbsolute(id) || id.startsWith('**')) {
return normalizePath$1(id);
}
@@ -3288,5 +3359,5 @@
if (process.versions.pnp) {
try {
- node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))('pnpapi');
+ node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))('pnpapi');
}
catch { }
@@ -3298,14 +3369,16 @@
return p.replace(windowsSlashRE, '/');
}
+// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
+node_module.builtinModules.filter((id) => !id.includes(':'));
function isInNodeModules(id) {
return id.includes('node_modules');
}
// TODO: use import()
-const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
+node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
// set in bin/vite.js
const filter = process.env.VITE_DEBUG_FILTER;
const DEBUG = process.env.DEBUG;
function createDebugger(namespace, options = {}) {
- const log = debug$1(namespace);
+ const log = debug$2(namespace);
const { onlyWhenFocused } = options;
let enabled = log.enabled;
@@ -3340,9 +3413,15 @@
function fsPathFromId(id) {
const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
- return fsPath[0] === '/' || fsPath.match(VOLUME_RE) ? fsPath : `/${fsPath}`;
+ return fsPath[0] === '/' || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
}
function fsPathFromUrl(url) {
return fsPathFromId(cleanUrl(url));
}
+function withTrailingSlash(path) {
+ if (path[path.length - 1] !== '/') {
+ return `${path}/`;
+ }
+ return path;
+}
/**
* Check if dir is a parent of file
@@ -3355,7 +3434,5 @@
*/
function isParentDirectory(dir, file) {
- if (dir[dir.length - 1] !== '/') {
- dir = `${dir}/`;
- }
+ dir = withTrailingSlash(dir);
return (file.startsWith(dir) ||
(isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase())));
@@ -3378,9 +3455,15 @@
return url.replace(postfixRE, '');
}
-function isObject(value) {
+const trailingSeparatorRE = /[?&]$/;
+const timestampRE = /\bt=\d{13}&?\b/;
+function removeTimestampQuery(url) {
+ return url.replace(timestampRE, '').replace(trailingSeparatorRE, '');
+}
+function isObject$1(value) {
return Object.prototype.toString.call(value) === '[object Object]';
}
function tryStatSync(file) {
try {
+ // The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
return fs$1.statSync(file, { throwIfNoEntry: false });
}
@@ -3390,9 +3473,8 @@
}
function isFileReadable(filename) {
+ if (!tryStatSync(filename)) {
+ return false;
+ }
try {
- // The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
- if (!fs$1.statSync(filename, { throwIfNoEntry: false })) {
- return false;
- }
// Check if current process has read permission to the file
fs$1.accessSync(filename, fs$1.constants.R_OK);
@@ -3406,19 +3488,14 @@
return Array.isArray(target) ? target : [target];
}
-// @ts-expect-error jest only exists when running Jest
-const usingDynamicImport = typeof jest === 'undefined';
-/**
- * Dynamically import files. It will make sure it's not being compiled away by TS/Rollup.
- *
- * As a temporary workaround for Jest's lack of stable ESM support, we fallback to require
- * if we're in a Jest environment.
- * See https://github.com/vitejs/vite/pull/5197#issuecomment-938054077
- *
- * @param file File path to import.
- */
-usingDynamicImport
- ? new Function('file', 'return import(file)')
- : _require;
-path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
+path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
+function backwardCompatibleWorkerPlugins(plugins) {
+ if (Array.isArray(plugins)) {
+ return plugins;
+ }
+ if (typeof plugins === 'function') {
+ return plugins();
+ }
+ return [];
+}
function mergeConfigRecursively(defaults, overrides, rootPath) {
const merged = { ...defaults };
@@ -3448,9 +3525,16 @@
continue;
}
+ else if (key === 'plugins' && rootPath === 'worker') {
+ merged[key] = () => [
+ ...backwardCompatibleWorkerPlugins(existing),
+ ...backwardCompatibleWorkerPlugins(value),
+ ];
+ continue;
+ }
if (Array.isArray(existing) || Array.isArray(value)) {
merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
continue;
}
- if (isObject(existing) && isObject(value)) {
+ if (isObject$1(existing) && isObject$1(value)) {
merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
continue;
@@ -3471,5 +3555,5 @@
if (!b)
return a;
- if (isObject(a) && isObject(b)) {
+ if (isObject$1(a) && isObject$1(b)) {
return { ...a, ...b };
}
@@ -3519,4 +3603,5 @@
// Don't use this manualChunks strategy for ssr, lib mode, and 'umd' or 'iife'
class SplitVendorChunkCache {
+ cache;
constructor() {
this.cache = new Map();
@@ -3616,4 +3701,243 @@
}
+var convertSourceMap$1 = {};
+
+(function (exports) {
+
+ Object.defineProperty(exports, 'commentRegex', {
+ get: function getCommentRegex () {
+ // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+ return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+ }
+ });
+
+
+ Object.defineProperty(exports, 'mapFileCommentRegex', {
+ get: function getMapFileCommentRegex () {
+ // Matches sourceMappingURL in either // or /* comment styles.
+ return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+ }
+ });
+
+ var decodeBase64;
+ if (typeof Buffer !== 'undefined') {
+ if (typeof Buffer.from === 'function') {
+ decodeBase64 = decodeBase64WithBufferFrom;
+ } else {
+ decodeBase64 = decodeBase64WithNewBuffer;
+ }
+ } else {
+ decodeBase64 = decodeBase64WithAtob;
+ }
+
+ function decodeBase64WithBufferFrom(base64) {
+ return Buffer.from(base64, 'base64').toString();
+ }
+
+ function decodeBase64WithNewBuffer(base64) {
+ if (typeof value === 'number') {
+ throw new TypeError('The value to decode must not be of type number.');
+ }
+ return new Buffer(base64, 'base64').toString();
+ }
+
+ function decodeBase64WithAtob(base64) {
+ return decodeURIComponent(escape(atob(base64)));
+ }
+
+ function stripComment(sm) {
+ return sm.split(',').pop();
+ }
+
+ function readFromFileMap(sm, read) {
+ var r = exports.mapFileCommentRegex.exec(sm);
+ // for some odd reason //# .. captures in 1 and /* .. */ in 2
+ var filename = r[1] || r[2];
+
+ try {
+ var sm = read(filename);
+ if (sm != null && typeof sm.catch === 'function') {
+ return sm.catch(throwError);
+ } else {
+ return sm;
+ }
+ } catch (e) {
+ throwError(e);
+ }
+
+ function throwError(e) {
+ throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+ }
+ }
+
+ function Converter (sm, opts) {
+ opts = opts || {};
+
+ if (opts.hasComment) {
+ sm = stripComment(sm);
+ }
+
+ if (opts.encoding === 'base64') {
+ sm = decodeBase64(sm);
+ } else if (opts.encoding === 'uri') {
+ sm = decodeURIComponent(sm);
+ }
+
+ if (opts.isJSON || opts.encoding) {
+ sm = JSON.parse(sm);
+ }
+
+ this.sourcemap = sm;
+ }
+
+ Converter.prototype.toJSON = function (space) {
+ return JSON.stringify(this.sourcemap, null, space);
+ };
+
+ if (typeof Buffer !== 'undefined') {
+ if (typeof Buffer.from === 'function') {
+ Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+ } else {
+ Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+ }
+ } else {
+ Converter.prototype.toBase64 = encodeBase64WithBtoa;
+ }
+
+ function encodeBase64WithBufferFrom() {
+ var json = this.toJSON();
+ return Buffer.from(json, 'utf8').toString('base64');
+ }
+
+ function encodeBase64WithNewBuffer() {
+ var json = this.toJSON();
+ if (typeof json === 'number') {
+ throw new TypeError('The json to encode must not be of type number.');
+ }
+ return new Buffer(json, 'utf8').toString('base64');
+ }
+
+ function encodeBase64WithBtoa() {
+ var json = this.toJSON();
+ return btoa(unescape(encodeURIComponent(json)));
+ }
+
+ Converter.prototype.toURI = function () {
+ var json = this.toJSON();
+ return encodeURIComponent(json);
+ };
+
+ Converter.prototype.toComment = function (options) {
+ var encoding, content, data;
+ if (options != null && options.encoding === 'uri') {
+ encoding = '';
+ content = this.toURI();
+ } else {
+ encoding = ';base64';
+ content = this.toBase64();
+ }
+ data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+ return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+ };
+
+ // returns copy instead of original
+ Converter.prototype.toObject = function () {
+ return JSON.parse(this.toJSON());
+ };
+
+ Converter.prototype.addProperty = function (key, value) {
+ if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+ return this.setProperty(key, value);
+ };
+
+ Converter.prototype.setProperty = function (key, value) {
+ this.sourcemap[key] = value;
+ return this;
+ };
+
+ Converter.prototype.getProperty = function (key) {
+ return this.sourcemap[key];
+ };
+
+ exports.fromObject = function (obj) {
+ return new Converter(obj);
+ };
+
+ exports.fromJSON = function (json) {
+ return new Converter(json, { isJSON: true });
+ };
+
+ exports.fromURI = function (uri) {
+ return new Converter(uri, { encoding: 'uri' });
+ };
+
+ exports.fromBase64 = function (base64) {
+ return new Converter(base64, { encoding: 'base64' });
+ };
+
+ exports.fromComment = function (comment) {
+ var m, encoding;
+ comment = comment
+ .replace(/^\/\*/g, '//')
+ .replace(/\*\/$/g, '');
+ m = exports.commentRegex.exec(comment);
+ encoding = m && m[4] || 'uri';
+ return new Converter(comment, { encoding: encoding, hasComment: true });
+ };
+
+ function makeConverter(sm) {
+ return new Converter(sm, { isJSON: true });
+ }
+
+ exports.fromMapFileComment = function (comment, read) {
+ if (typeof read === 'string') {
+ throw new Error(
+ 'String directory paths are no longer supported with `fromMapFileComment`\n' +
+ 'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+ )
+ }
+
+ var sm = readFromFileMap(comment, read);
+ if (sm != null && typeof sm.then === 'function') {
+ return sm.then(makeConverter);
+ } else {
+ return makeConverter(sm);
+ }
+ };
+
+ // Finds last sourcemap comment in file or returns null if none was found
+ exports.fromSource = function (content) {
+ var m = content.match(exports.commentRegex);
+ return m ? exports.fromComment(m.pop()) : null;
+ };
+
+ // Finds last sourcemap comment in file or returns null if none was found
+ exports.fromMapFileSource = function (content, read) {
+ if (typeof read === 'string') {
+ throw new Error(
+ 'String directory paths are no longer supported with `fromMapFileSource`\n' +
+ 'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+ )
+ }
+ var m = content.match(exports.mapFileCommentRegex);
+ return m ? exports.fromMapFileComment(m.pop(), read) : null;
+ };
+
+ exports.removeComments = function (src) {
+ return src.replace(exports.commentRegex, '');
+ };
+
+ exports.removeMapFileComments = function (src) {
+ return src.replace(exports.mapFileCommentRegex, '');
+ };
+
+ exports.generateMapFileComment = function (file, options) {
+ var data = 'sourceMappingURL=' + file;
+ return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+ };
+} (convertSourceMap$1));
+
+var convertSourceMap = /*@__PURE__*/getDefaultExportFromCjs(convertSourceMap$1);
+
/*!
* etag
@@ -3642,5 +3966,5 @@
*/
-var toString = Object.prototype.toString;
+var toString$1 = Object.prototype.toString;
/**
@@ -3725,6 +4049,6 @@
// quack quack
return obj && typeof obj === 'object' &&
- 'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
- 'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
+ 'ctime' in obj && toString$1.call(obj.ctime) === '[object Date]' &&
+ 'mtime' in obj && toString$1.call(obj.mtime) === '[object Date]' &&
'ino' in obj && typeof obj.ino === 'number' &&
'size' in obj && typeof obj.size === 'number'
@@ -3748,5 +4072,1206 @@
var getEtag = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
-const debug = createDebugger('vite:sourcemap', {
+class BitSet {
+ constructor(arg) {
+ this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+ }
+
+ add(n) {
+ this.bits[n >> 5] |= 1 << (n & 31);
+ }
+
+ has(n) {
+ return !!(this.bits[n >> 5] & (1 << (n & 31)));
+ }
+}
+
+class Chunk {
+ constructor(start, end, content) {
+ this.start = start;
+ this.end = end;
+ this.original = content;
+
+ this.intro = '';
+ this.outro = '';
+
+ this.content = content;
+ this.storeName = false;
+ this.edited = false;
+
+ {
+ this.previous = null;
+ this.next = null;
+ }
+ }
+
+ appendLeft(content) {
+ this.outro += content;
+ }
+
+ appendRight(content) {
+ this.intro = this.intro + content;
+ }
+
+ clone() {
+ const chunk = new Chunk(this.start, this.end, this.original);
+
+ chunk.intro = this.intro;
+ chunk.outro = this.outro;
+ chunk.content = this.content;
+ chunk.storeName = this.storeName;
+ chunk.edited = this.edited;
+
+ return chunk;
+ }
+
+ contains(index) {
+ return this.start < index && index < this.end;
+ }
+
+ eachNext(fn) {
+ let chunk = this;
+ while (chunk) {
+ fn(chunk);
+ chunk = chunk.next;
+ }
+ }
+
+ eachPrevious(fn) {
+ let chunk = this;
+ while (chunk) {
+ fn(chunk);
+ chunk = chunk.previous;
+ }
+ }
+
+ edit(content, storeName, contentOnly) {
+ this.content = content;
+ if (!contentOnly) {
+ this.intro = '';
+ this.outro = '';
+ }
+ this.storeName = storeName;
+
+ this.edited = true;
+
+ return this;
+ }
+
+ prependLeft(content) {
+ this.outro = content + this.outro;
+ }
+
+ prependRight(content) {
+ this.intro = content + this.intro;
+ }
+
+ split(index) {
+ const sliceIndex = index - this.start;
+
+ const originalBefore = this.original.slice(0, sliceIndex);
+ const originalAfter = this.original.slice(sliceIndex);
+
+ this.original = originalBefore;
+
+ const newChunk = new Chunk(index, this.end, originalAfter);
+ newChunk.outro = this.outro;
+ this.outro = '';
+
+ this.end = index;
+
+ if (this.edited) {
+ // after split we should save the edit content record into the correct chunk
+ // to make sure sourcemap correct
+ // For example:
+ // ' test'.trim()
+ // split -> ' ' + 'test'
+ // ✔️ edit -> '' + 'test'
+ // ✖️ edit -> 'test' + ''
+ // TODO is this block necessary?...
+ newChunk.edit('', false);
+ this.content = '';
+ } else {
+ this.content = originalBefore;
+ }
+
+ newChunk.next = this.next;
+ if (newChunk.next) newChunk.next.previous = newChunk;
+ newChunk.previous = this;
+ this.next = newChunk;
+
+ return newChunk;
+ }
+
+ toString() {
+ return this.intro + this.content + this.outro;
+ }
+
+ trimEnd(rx) {
+ this.outro = this.outro.replace(rx, '');
+ if (this.outro.length) return true;
+
+ const trimmed = this.content.replace(rx, '');
+
+ if (trimmed.length) {
+ if (trimmed !== this.content) {
+ this.split(this.start + trimmed.length).edit('', undefined, true);
+ if (this.edited) {
+ // save the change, if it has been edited
+ this.edit(trimmed, this.storeName, true);
+ }
+ }
+ return true;
+ } else {
+ this.edit('', undefined, true);
+
+ this.intro = this.intro.replace(rx, '');
+ if (this.intro.length) return true;
+ }
+ }
+
+ trimStart(rx) {
+ this.intro = this.intro.replace(rx, '');
+ if (this.intro.length) return true;
+
+ const trimmed = this.content.replace(rx, '');
+
+ if (trimmed.length) {
+ if (trimmed !== this.content) {
+ const newChunk = this.split(this.end - trimmed.length);
+ if (this.edited) {
+ // save the change, if it has been edited
+ newChunk.edit(trimmed, this.storeName, true);
+ }
+ this.edit('', undefined, true);
+ }
+ return true;
+ } else {
+ this.edit('', undefined, true);
+
+ this.outro = this.outro.replace(rx, '');
+ if (this.outro.length) return true;
+ }
+ }
+}
+
+function getBtoa() {
+ if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+ return (str) => window.btoa(unescape(encodeURIComponent(str)));
+ } else if (typeof Buffer === 'function') {
+ return (str) => Buffer.from(str, 'utf-8').toString('base64');
+ } else {
+ return () => {
+ throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+ };
+ }
+}
+
+const btoa$1 = /*#__PURE__*/ getBtoa();
+
+class SourceMap {
+ constructor(properties) {
+ this.version = 3;
+ this.file = properties.file;
+ this.sources = properties.sources;
+ this.sourcesContent = properties.sourcesContent;
+ this.names = properties.names;
+ this.mappings = encode(properties.mappings);
+ if (typeof properties.x_google_ignoreList !== 'undefined') {
+ this.x_google_ignoreList = properties.x_google_ignoreList;
+ }
+ }
+
+ toString() {
+ return JSON.stringify(this);
+ }
+
+ toUrl() {
+ return 'data:application/json;charset=utf-8;base64,' + btoa$1(this.toString());
+ }
+}
+
+function guessIndent(code) {
+ const lines = code.split('\n');
+
+ const tabbed = lines.filter((line) => /^\t+/.test(line));
+ const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+ if (tabbed.length === 0 && spaced.length === 0) {
+ return null;
+ }
+
+ // More lines tabbed than spaced? Assume tabs, and
+ // default to tabs in the case of a tie (or nothing
+ // to go on)
+ if (tabbed.length >= spaced.length) {
+ return '\t';
+ }
+
+ // Otherwise, we need to guess the multiple
+ const min = spaced.reduce((previous, current) => {
+ const numSpaces = /^ +/.exec(current)[0].length;
+ return Math.min(numSpaces, previous);
+ }, Infinity);
+
+ return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+ const fromParts = from.split(/[/\\]/);
+ const toParts = to.split(/[/\\]/);
+
+ fromParts.pop(); // get dirname
+
+ while (fromParts[0] === toParts[0]) {
+ fromParts.shift();
+ toParts.shift();
+ }
+
+ if (fromParts.length) {
+ let i = fromParts.length;
+ while (i--) fromParts[i] = '..';
+ }
+
+ return fromParts.concat(toParts).join('/');
+}
+
+const toString = Object.prototype.toString;
+
+function isObject(thing) {
+ return toString.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+ const originalLines = source.split('\n');
+ const lineOffsets = [];
+
+ for (let i = 0, pos = 0; i < originalLines.length; i++) {
+ lineOffsets.push(pos);
+ pos += originalLines[i].length + 1;
+ }
+
+ return function locate(index) {
+ let i = 0;
+ let j = lineOffsets.length;
+ while (i < j) {
+ const m = (i + j) >> 1;
+ if (index < lineOffsets[m]) {
+ j = m;
+ } else {
+ i = m + 1;
+ }
+ }
+ const line = i - 1;
+ const column = index - lineOffsets[line];
+ return { line, column };
+ };
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+ constructor(hires) {
+ this.hires = hires;
+ this.generatedCodeLine = 0;
+ this.generatedCodeColumn = 0;
+ this.raw = [];
+ this.rawSegments = this.raw[this.generatedCodeLine] = [];
+ this.pending = null;
+ }
+
+ addEdit(sourceIndex, content, loc, nameIndex) {
+ if (content.length) {
+ let contentLineEnd = content.indexOf('\n', 0);
+ let previousContentLineEnd = -1;
+ while (contentLineEnd >= 0) {
+ const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+ if (nameIndex >= 0) {
+ segment.push(nameIndex);
+ }
+ this.rawSegments.push(segment);
+
+ this.generatedCodeLine += 1;
+ this.raw[this.generatedCodeLine] = this.rawSegments = [];
+ this.generatedCodeColumn = 0;
+
+ previousContentLineEnd = contentLineEnd;
+ contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+ }
+
+ const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+ if (nameIndex >= 0) {
+ segment.push(nameIndex);
+ }
+ this.rawSegments.push(segment);
+
+ this.advance(content.slice(previousContentLineEnd + 1));
+ } else if (this.pending) {
+ this.rawSegments.push(this.pending);
+ this.advance(content);
+ }
+
+ this.pending = null;
+ }
+
+ addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+ let originalCharIndex = chunk.start;
+ let first = true;
+ // when iterating each char, check if it's in a word boundary
+ let charInHiresBoundary = false;
+
+ while (originalCharIndex < chunk.end) {
+ if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+ const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+ if (this.hires === 'boundary') {
+ // in hires "boundary", group segments per word boundary than per char
+ if (wordRegex.test(original[originalCharIndex])) {
+ // for first char in the boundary found, start the boundary by pushing a segment
+ if (!charInHiresBoundary) {
+ this.rawSegments.push(segment);
+ charInHiresBoundary = true;
+ }
+ } else {
+ // for non-word char, end the boundary by pushing a segment
+ this.rawSegments.push(segment);
+ charInHiresBoundary = false;
+ }
+ } else {
+ this.rawSegments.push(segment);
+ }
+ }
+
+ if (original[originalCharIndex] === '\n') {
+ loc.line += 1;
+ loc.column = 0;
+ this.generatedCodeLine += 1;
+ this.raw[this.generatedCodeLine] = this.rawSegments = [];
+ this.generatedCodeColumn = 0;
+ first = true;
+ } else {
+ loc.column += 1;
+ this.generatedCodeColumn += 1;
+ first = false;
+ }
+
+ originalCharIndex += 1;
+ }
+
+ this.pending = null;
+ }
+
+ advance(str) {
+ if (!str) return;
+
+ const lines = str.split('\n');
+
+ if (lines.length > 1) {
+ for (let i = 0; i < lines.length - 1; i++) {
+ this.generatedCodeLine++;
+ this.raw[this.generatedCodeLine] = this.rawSegments = [];
+ }
+ this.generatedCodeColumn = 0;
+ }
+
+ this.generatedCodeColumn += lines[lines.length - 1].length;
+ }
+}
+
+const n = '\n';
+
+const warned = {
+ insertLeft: false,
+ insertRight: false,
+ storeName: false,
+};
+
+class MagicString {
+ constructor(string, options = {}) {
+ const chunk = new Chunk(0, string.length, string);
+
+ Object.defineProperties(this, {
+ original: { writable: true, value: string },
+ outro: { writable: true, value: '' },
+ intro: { writable: true, value: '' },
+ firstChunk: { writable: true, value: chunk },
+ lastChunk: { writable: true, value: chunk },
+ lastSearchedChunk: { writable: true, value: chunk },
+ byStart: { writable: true, value: {} },
+ byEnd: { writable: true, value: {} },
+ filename: { writable: true, value: options.filename },
+ indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+ sourcemapLocations: { writable: true, value: new BitSet() },
+ storedNames: { writable: true, value: {} },
+ indentStr: { writable: true, value: undefined },
+ ignoreList: { writable: true, value: options.ignoreList },
+ });
+
+ this.byStart[0] = chunk;
+ this.byEnd[string.length] = chunk;
+ }
+
+ addSourcemapLocation(char) {
+ this.sourcemapLocations.add(char);
+ }
+
+ append(content) {
+ if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+ this.outro += content;
+ return this;
+ }
+
+ appendLeft(index, content) {
+ if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+ this._split(index);
+
+ const chunk = this.byEnd[index];
+
+ if (chunk) {
+ chunk.appendLeft(content);
+ } else {
+ this.intro += content;
+ }
+ return this;
+ }
+
+ appendRight(index, content) {
+ if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+ this._split(index);
+
+ const chunk = this.byStart[index];
+
+ if (chunk) {
+ chunk.appendRight(content);
+ } else {
+ this.outro += content;
+ }
+ return this;
+ }
+
+ clone() {
+ const cloned = new MagicString(this.original, { filename: this.filename });
+
+ let originalChunk = this.firstChunk;
+ let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+ while (originalChunk) {
+ cloned.byStart[clonedChunk.start] = clonedChunk;
+ cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+ const nextOriginalChunk = originalChunk.next;
+ const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+ if (nextClonedChunk) {
+ clonedChunk.next = nextClonedChunk;
+ nextClonedChunk.previous = clonedChunk;
+
+ clonedChunk = nextClonedChunk;
+ }
+
+ originalChunk = nextOriginalChunk;
+ }
+
+ cloned.lastChunk = clonedChunk;
+
+ if (this.indentExclusionRanges) {
+ cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+ }
+
+ cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+ cloned.intro = this.intro;
+ cloned.outro = this.outro;
+
+ return cloned;
+ }
+
+ generateDecodedMap(options) {
+ options = options || {};
+
+ const sourceIndex = 0;
+ const names = Object.keys(this.storedNames);
+ const mappings = new Mappings(options.hires);
+
+ const locate = getLocator(this.original);
+
+ if (this.intro) {
+ mappings.advance(this.intro);
+ }
+
+ this.firstChunk.eachNext((chunk) => {
+ const loc = locate(chunk.start);
+
+ if (chunk.intro.length) mappings.advance(chunk.intro);
+
+ if (chunk.edited) {
+ mappings.addEdit(
+ sourceIndex,
+ chunk.content,
+ loc,
+ chunk.storeName ? names.indexOf(chunk.original) : -1,
+ );
+ } else {
+ mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+ }
+
+ if (chunk.outro.length) mappings.advance(chunk.outro);
+ });
+
+ return {
+ file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+ sources: [
+ options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+ ],
+ sourcesContent: options.includeContent ? [this.original] : undefined,
+ names,
+ mappings: mappings.raw,
+ x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+ };
+ }
+
+ generateMap(options) {
+ return new SourceMap(this.generateDecodedMap(options));
+ }
+
+ _ensureindentStr() {
+ if (this.indentStr === undefined) {
+ this.indentStr = guessIndent(this.original);
+ }
+ }
+
+ _getRawIndentString() {
+ this._ensureindentStr();
+ return this.indentStr;
+ }
+
+ getIndentString() {
+ this._ensureindentStr();
+ return this.indentStr === null ? '\t' : this.indentStr;
+ }
+
+ indent(indentStr, options) {
+ const pattern = /^[^\r\n]/gm;
+
+ if (isObject(indentStr)) {
+ options = indentStr;
+ indentStr = undefined;
+ }
+
+ if (indentStr === undefined) {
+ this._ensureindentStr();
+ indentStr = this.indentStr || '\t';
+ }
+
+ if (indentStr === '') return this; // noop
+
+ options = options || {};
+
+ // Process exclusion ranges
+ const isExcluded = {};
+
+ if (options.exclude) {
+ const exclusions =
+ typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+ exclusions.forEach((exclusion) => {
+ for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+ isExcluded[i] = true;
+ }
+ });
+ }
+
+ let shouldIndentNextCharacter = options.indentStart !== false;
+ const replacer = (match) => {
+ if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+ shouldIndentNextCharacter = true;
+ return match;
+ };
+
+ this.intro = this.intro.replace(pattern, replacer);
+
+ let charIndex = 0;
+ let chunk = this.firstChunk;
+
+ while (chunk) {
+ const end = chunk.end;
+
+ if (chunk.edited) {
+ if (!isExcluded[charIndex]) {
+ chunk.content = chunk.content.replace(pattern, replacer);
+
+ if (chunk.content.length) {
+ shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+ }
+ }
+ } else {
+ charIndex = chunk.start;
+
+ while (charIndex < end) {
+ if (!isExcluded[charIndex]) {
+ const char = this.original[charIndex];
+
+ if (char === '\n') {
+ shouldIndentNextCharacter = true;
+ } else if (char !== '\r' && shouldIndentNextCharacter) {
+ shouldIndentNextCharacter = false;
+
+ if (charIndex === chunk.start) {
+ chunk.prependRight(indentStr);
+ } else {
+ this._splitChunk(chunk, charIndex);
+ chunk = chunk.next;
+ chunk.prependRight(indentStr);
+ }
+ }
+ }
+
+ charIndex += 1;
+ }
+ }
+
+ charIndex = chunk.end;
+ chunk = chunk.next;
+ }
+
+ this.outro = this.outro.replace(pattern, replacer);
+
+ return this;
+ }
+
+ insert() {
+ throw new Error(
+ 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+ );
+ }
+
+ insertLeft(index, content) {
+ if (!warned.insertLeft) {
+ console.warn(
+ 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+ ); // eslint-disable-line no-console
+ warned.insertLeft = true;
+ }
+
+ return this.appendLeft(index, content);
+ }
+
+ insertRight(index, content) {
+ if (!warned.insertRight) {
+ console.warn(
+ 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+ ); // eslint-disable-line no-console
+ warned.insertRight = true;
+ }
+
+ return this.prependRight(index, content);
+ }
+
+ move(start, end, index) {
+ if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+ this._split(start);
+ this._split(end);
+ this._split(index);
+
+ const first = this.byStart[start];
+ const last = this.byEnd[end];
+
+ const oldLeft = first.previous;
+ const oldRight = last.next;
+
+ const newRight = this.byStart[index];
+ if (!newRight && last === this.lastChunk) return this;
+ const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+ if (oldLeft) oldLeft.next = oldRight;
+ if (oldRight) oldRight.previous = oldLeft;
+
+ if (newLeft) newLeft.next = first;
+ if (newRight) newRight.previous = last;
+
+ if (!first.previous) this.firstChunk = last.next;
+ if (!last.next) {
+ this.lastChunk = first.previous;
+ this.lastChunk.next = null;
+ }
+
+ first.previous = newLeft;
+ last.next = newRight || null;
+
+ if (!newLeft) this.firstChunk = first;
+ if (!newRight) this.lastChunk = last;
+ return this;
+ }
+
+ overwrite(start, end, content, options) {
+ options = options || {};
+ return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+ }
+
+ update(start, end, content, options) {
+ if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+ while (start < 0) start += this.original.length;
+ while (end < 0) end += this.original.length;
+
+ if (end > this.original.length) throw new Error('end is out of bounds');
+ if (start === end)
+ throw new Error(
+ 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+ );
+
+ this._split(start);
+ this._split(end);
+
+ if (options === true) {
+ if (!warned.storeName) {
+ console.warn(
+ 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+ ); // eslint-disable-line no-console
+ warned.storeName = true;
+ }
+
+ options = { storeName: true };
+ }
+ const storeName = options !== undefined ? options.storeName : false;
+ const overwrite = options !== undefined ? options.overwrite : false;
+
+ if (storeName) {
+ const original = this.original.slice(start, end);
+ Object.defineProperty(this.storedNames, original, {
+ writable: true,
+ value: true,
+ enumerable: true,
+ });
+ }
+
+ const first = this.byStart[start];
+ const last = this.byEnd[end];
+
+ if (first) {
+ let chunk = first;
+ while (chunk !== last) {
+ if (chunk.next !== this.byStart[chunk.end]) {
+ throw new Error('Cannot overwrite across a split point');
+ }
+ chunk = chunk.next;
+ chunk.edit('', false);
+ }
+
+ first.edit(content, storeName, !overwrite);
+ } else {
+ // must be inserting at the end
+ const newChunk = new Chunk(start, end, '').edit(content, storeName);
+
+ // TODO last chunk in the array may not be the last chunk, if it's moved...
+ last.next = newChunk;
+ newChunk.previous = last;
+ }
+ return this;
+ }
+
+ prepend(content) {
+ if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+ this.intro = content + this.intro;
+ return this;
+ }
+
+ prependLeft(index, content) {
+ if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+ this._split(index);
+
+ const chunk = this.byEnd[index];
+
+ if (chunk) {
+ chunk.prependLeft(content);
+ } else {
+ this.intro = content + this.intro;
+ }
+ return this;
+ }
+
+ prependRight(index, content) {
+ if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+ this._split(index);
+
+ const chunk = this.byStart[index];
+
+ if (chunk) {
+ chunk.prependRight(content);
+ } else {
+ this.outro = content + this.outro;
+ }
+ return this;
+ }
+
+ remove(start, end) {
+ while (start < 0) start += this.original.length;
+ while (end < 0) end += this.original.length;
+
+ if (start === end) return this;
+
+ if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+ if (start > end) throw new Error('end must be greater than start');
+
+ this._split(start);
+ this._split(end);
+
+ let chunk = this.byStart[start];
+
+ while (chunk) {
+ chunk.intro = '';
+ chunk.outro = '';
+ chunk.edit('');
+
+ chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+ }
+ return this;
+ }
+
+ lastChar() {
+ if (this.outro.length) return this.outro[this.outro.length - 1];
+ let chunk = this.lastChunk;
+ do {
+ if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+ if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+ if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+ } while ((chunk = chunk.previous));
+ if (this.intro.length) return this.intro[this.intro.length - 1];
+ return '';
+ }
+
+ lastLine() {
+ let lineIndex = this.outro.lastIndexOf(n);
+ if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+ let lineStr = this.outro;
+ let chunk = this.lastChunk;
+ do {
+ if (chunk.outro.length > 0) {
+ lineIndex = chunk.outro.lastIndexOf(n);
+ if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+ lineStr = chunk.outro + lineStr;
+ }
+
+ if (chunk.content.length > 0) {
+ lineIndex = chunk.content.lastIndexOf(n);
+ if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+ lineStr = chunk.content + lineStr;
+ }
+
+ if (chunk.intro.length > 0) {
+ lineIndex = chunk.intro.lastIndexOf(n);
+ if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+ lineStr = chunk.intro + lineStr;
+ }
+ } while ((chunk = chunk.previous));
+ lineIndex = this.intro.lastIndexOf(n);
+ if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+ return this.intro + lineStr;
+ }
+
+ slice(start = 0, end = this.original.length) {
+ while (start < 0) start += this.original.length;
+ while (end < 0) end += this.original.length;
+
+ let result = '';
+
+ // find start chunk
+ let chunk = this.firstChunk;
+ while (chunk && (chunk.start > start || chunk.end <= start)) {
+ // found end chunk before start
+ if (chunk.start < end && chunk.end >= end) {
+ return result;
+ }
+
+ chunk = chunk.next;
+ }
+
+ if (chunk && chunk.edited && chunk.start !== start)
+ throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+ const startChunk = chunk;
+ while (chunk) {
+ if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+ result += chunk.intro;
+ }
+
+ const containsEnd = chunk.start < end && chunk.end >= end;
+ if (containsEnd && chunk.edited && chunk.end !== end)
+ throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+ const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+ const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+ result += chunk.content.slice(sliceStart, sliceEnd);
+
+ if (chunk.outro && (!containsEnd || chunk.end === end)) {
+ result += chunk.outro;
+ }
+
+ if (containsEnd) {
+ break;
+ }
+
+ chunk = chunk.next;
+ }
+
+ return result;
+ }
+
+ // TODO deprecate this? not really very useful
+ snip(start, end) {
+ const clone = this.clone();
+ clone.remove(0, start);
+ clone.remove(end, clone.original.length);
+
+ return clone;
+ }
+
+ _split(index) {
+ if (this.byStart[index] || this.byEnd[index]) return;
+
+ let chunk = this.lastSearchedChunk;
+ const searchForward = index > chunk.end;
+
+ while (chunk) {
+ if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+ chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+ }
+ }
+
+ _splitChunk(chunk, index) {
+ if (chunk.edited && chunk.content.length) {
+ // zero-length edited chunks are a special case (overlapping replacements)
+ const loc = getLocator(this.original)(index);
+ throw new Error(
+ `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+ );
+ }
+
+ const newChunk = chunk.split(index);
+
+ this.byEnd[index] = chunk;
+ this.byStart[index] = newChunk;
+ this.byEnd[newChunk.end] = newChunk;
+
+ if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+ this.lastSearchedChunk = chunk;
+ return true;
+ }
+
+ toString() {
+ let str = this.intro;
+
+ let chunk = this.firstChunk;
+ while (chunk) {
+ str += chunk.toString();
+ chunk = chunk.next;
+ }
+
+ return str + this.outro;
+ }
+
+ isEmpty() {
+ let chunk = this.firstChunk;
+ do {
+ if (
+ (chunk.intro.length && chunk.intro.trim()) ||
+ (chunk.content.length && chunk.content.trim()) ||
+ (chunk.outro.length && chunk.outro.trim())
+ )
+ return false;
+ } while ((chunk = chunk.next));
+ return true;
+ }
+
+ length() {
+ let chunk = this.firstChunk;
+ let length = 0;
+ do {
+ length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+ } while ((chunk = chunk.next));
+ return length;
+ }
+
+ trimLines() {
+ return this.trim('[\\r\\n]');
+ }
+
+ trim(charType) {
+ return this.trimStart(charType).trimEnd(charType);
+ }
+
+ trimEndAborted(charType) {
+ const rx = new RegExp((charType || '\\s') + '+$');
+
+ this.outro = this.outro.replace(rx, '');
+ if (this.outro.length) return true;
+
+ let chunk = this.lastChunk;
+
+ do {
+ const end = chunk.end;
+ const aborted = chunk.trimEnd(rx);
+
+ // if chunk was trimmed, we have a new lastChunk
+ if (chunk.end !== end) {
+ if (this.lastChunk === chunk) {
+ this.lastChunk = chunk.next;
+ }
+
+ this.byEnd[chunk.end] = chunk;
+ this.byStart[chunk.next.start] = chunk.next;
+ this.byEnd[chunk.next.end] = chunk.next;
+ }
+
+ if (aborted) return true;
+ chunk = chunk.previous;
+ } while (chunk);
+
+ return false;
+ }
+
+ trimEnd(charType) {
+ this.trimEndAborted(charType);
+ return this;
+ }
+ trimStartAborted(charType) {
+ const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+ this.intro = this.intro.replace(rx, '');
+ if (this.intro.length) return true;
+
+ let chunk = this.firstChunk;
+
+ do {
+ const end = chunk.end;
+ const aborted = chunk.trimStart(rx);
+
+ if (chunk.end !== end) {
+ // special case...
+ if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+ this.byEnd[chunk.end] = chunk;
+ this.byStart[chunk.next.start] = chunk.next;
+ this.byEnd[chunk.next.end] = chunk.next;
+ }
+
+ if (aborted) return true;
+ chunk = chunk.next;
+ } while (chunk);
+
+ return false;
+ }
+
+ trimStart(charType) {
+ this.trimStartAborted(charType);
+ return this;
+ }
+
+ hasChanged() {
+ return this.original !== this.toString();
+ }
+
+ _replaceRegexp(searchValue, replacement) {
+ function getReplacement(match, str) {
+ if (typeof replacement === 'string') {
+ return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+ // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+ if (i === '$') return '$';
+ if (i === '&') return match[0];
+ const num = +i;
+ if (num < match.length) return match[+i];
+ return `$${i}`;
+ });
+ } else {
+ return replacement(...match, match.index, str, match.groups);
+ }
+ }
+ function matchAll(re, str) {
+ let match;
+ const matches = [];
+ while ((match = re.exec(str))) {
+ matches.push(match);
+ }
+ return matches;
+ }
+ if (searchValue.global) {
+ const matches = matchAll(searchValue, this.original);
+ matches.forEach((match) => {
+ if (match.index != null)
+ this.overwrite(
+ match.index,
+ match.index + match[0].length,
+ getReplacement(match, this.original),
+ );
+ });
+ } else {
+ const match = this.original.match(searchValue);
+ if (match && match.index != null)
+ this.overwrite(
+ match.index,
+ match.index + match[0].length,
+ getReplacement(match, this.original),
+ );
+ }
+ return this;
+ }
+
+ _replaceString(string, replacement) {
+ const { original } = this;
+ const index = original.indexOf(string);
+
+ if (index !== -1) {
+ this.overwrite(index, index + string.length, replacement);
+ }
+
+ return this;
+ }
+
+ replace(searchValue, replacement) {
+ if (typeof searchValue === 'string') {
+ return this._replaceString(searchValue, replacement);
+ }
+
+ return this._replaceRegexp(searchValue, replacement);
+ }
+
+ _replaceAllString(string, replacement) {
+ const { original } = this;
+ const stringLength = string.length;
+ for (
+ let index = original.indexOf(string);
+ index !== -1;
+ index = original.indexOf(string, index + stringLength)
+ ) {
+ this.overwrite(index, index + stringLength, replacement);
+ }
+
+ return this;
+ }
+
+ replaceAll(searchValue, replacement) {
+ if (typeof searchValue === 'string') {
+ return this._replaceAllString(searchValue, replacement);
+ }
+
+ if (!searchValue.global) {
+ throw new TypeError(
+ 'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+ );
+ }
+
+ return this._replaceRegexp(searchValue, replacement);
+ }
+}
+
+const debug$1 = createDebugger('vite:sourcemap', {
onlyWhenFocused: true,
});
@@ -3758,5 +5283,5 @@
}
function getCodeWithSourcemap(type, code, map) {
- if (debug) {
+ if (debug$1) {
code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, '*\\/')}*/\n`;
}
@@ -3770,4 +5295,7 @@
}
+const debug = createDebugger('vite:send', {
+ onlyWhenFocused: true,
+});
const alias = {
js: 'application/javascript',
@@ -3795,9 +5323,27 @@
}
// inject source map reference
- if (map && map.mappings) {
+ if (map && 'version' in map && map.mappings) {
if (type === 'js' || type === 'css') {
content = getCodeWithSourcemap(type, conte(too long so truncated)
Command detailsnpm diff --diff=vite@4.4.9 --diff=vite@5.0.5 --diff-unified=2See also the Reported by ybiquitous/npm-diff-action@v1.5.0 (Node.js 20.10.0 and npm 10.2.4) |
|
Superseded by #1279. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Bumps vite from 4.4.9 to 5.0.5.
Release notes
Sourced from vite's releases.
Changelog
Sourced from vite's changelog.
... (truncated)
Commits
fa79767release: v5.0.5ad3addafix(deps): update all non-major dependencies (#15233)d93a211feat: add '*.mov' to client.d.ts (#15189)5f2cdecfix(hmr): don't consider CSS dep as a circular dep (#15229)ee12f30chore: replace 'some' with 'includes' in resolveEnvPrefix (#15220)14be75ffix: json error with position (#15225)0348137refactor: use dedicated regex methods (#15228)5b85040fix: proxy html path should be encoded (#15223)1df1fd1perf: skip computing sourceRoot in injectSourcesContent (#15207)7fd7c6cfeat(server): allow disabling built-in shortcuts (#15218)Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting
@dependabot rebase.Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR:
@dependabot rebasewill rebase this PR@dependabot recreatewill recreate this PR, overwriting any edits that have been made to it@dependabot mergewill merge this PR after your CI passes on it@dependabot squash and mergewill squash and merge this PR after your CI passes on it@dependabot cancel mergewill cancel a previously requested merge and block automerging@dependabot reopenwill reopen this PR if it is closed@dependabot closewill close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually@dependabot show <dependency name> ignore conditionswill show all of the ignore conditions of the specified dependency@dependabot ignore this major versionwill close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this minor versionwill close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this dependencywill close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)You can disable automated security fix PRs for this repo from the Security Alerts page.