@cloudflare/vite-plugin 1.17.0 → 1.18.0

package/dist/index.mjs

@@ -1,13 +1,14 @@
 import { builtinModules } from "node:module";
-import * as vite from "vite";
 import assert from "node:assert";
-import { CoreHeaders, Log, LogLevel, Miniflare, Request as Request$1, Response as Response$1, coupleWebSocket, getDefaultDevRegistryPath, getNodeCompat, kUnsafeEphemeralUniqueKey } from "miniflare";
-import { maybeStartOrUpdateRemoteProxySession, unstable_convertConfigBindingsToStartWorkerBindings, unstable_defaultWranglerConfig, unstable_getDevCompatibilityDate, unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, unstable_getVarsForDev, unstable_getWorkerNameFromProject, unstable_readConfig } from "wrangler";
-import * as path$1 from "node:path";
+import { CoreHeaders, Log, LogLevel, Miniflare, Request as Request$1, Response as Response$1, coupleWebSocket, getDefaultDevRegistryPath, getNodeCompat, getWorkerRegistry, kUnsafeEphemeralUniqueKey } from "miniflare";
+import * as wrangler from "wrangler";
+import * as nodePath from "node:path";
 import path, { relative } from "node:path";
 import * as util$1 from "node:util";
 import { format, inspect } from "node:util";
 import { createHeaders, createRequest, sendResponse } from "@remix-run/node-fetch-server";
+import * as vite from "vite";
+import { version } from "vite";
 import { defu } from "defu";
 import * as fs$1 from "node:fs";
 import fs, { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
@@ -49,8 +50,1451 @@ var __toESM = (mod, isNodeMode, target$1) => (target$1 = mod != null ? __create(
 	enumerable: true
 }) : target$1, mod));
 
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js
+var require_constants = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js": ((exports, module) => {
+	const SEMVER_SPEC_VERSION = "2.0.0";
+	const MAX_LENGTH$2 = 256;
+	const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || 9007199254740991;
+	const MAX_SAFE_COMPONENT_LENGTH$1 = 16;
+	const MAX_SAFE_BUILD_LENGTH$1 = MAX_LENGTH$2 - 6;
+	const RELEASE_TYPES = [
+		"major",
+		"premajor",
+		"minor",
+		"preminor",
+		"patch",
+		"prepatch",
+		"prerelease"
+	];
+	module.exports = {
+		MAX_LENGTH: MAX_LENGTH$2,
+		MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH$1,
+		MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH$1,
+		MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+		RELEASE_TYPES,
+		SEMVER_SPEC_VERSION,
+		FLAG_INCLUDE_PRERELEASE: 1,
+		FLAG_LOOSE: 2
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
+var require_debug = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js": ((exports, module) => {
+	const debug$4 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+	module.exports = debug$4;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js
+var require_re = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js": ((exports, module) => {
+	const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH: MAX_LENGTH$1 } = require_constants();
+	const debug$3 = require_debug();
+	exports = module.exports = {};
+	const re$4 = exports.re = [];
+	const safeRe = exports.safeRe = [];
+	const src = exports.src = [];
+	const safeSrc = exports.safeSrc = [];
+	const t$4 = exports.t = {};
+	let R = 0;
+	const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+	const safeRegexReplacements = [
+		["\\s", 1],
+		["\\d", MAX_LENGTH$1],
+		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+	];
+	const makeSafeRegex = (value) => {
+		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+		return value;
+	};
+	const createToken = (name, value, isGlobal) => {
+		const safe = makeSafeRegex(value);
+		const index = R++;
+		debug$3(name, index, value);
+		t$4[name] = index;
+		src[index] = value;
+		safeSrc[index] = safe;
+		re$4[index] = new RegExp(value, isGlobal ? "g" : void 0);
+		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+	};
+	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+	createToken("MAINVERSION", `(${src[t$4.NUMERICIDENTIFIER]})\\.(${src[t$4.NUMERICIDENTIFIER]})\\.(${src[t$4.NUMERICIDENTIFIER]})`);
+	createToken("MAINVERSIONLOOSE", `(${src[t$4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$4.NUMERICIDENTIFIERLOOSE]})\\.(${src[t$4.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASEIDENTIFIER", `(?:${src[t$4.NONNUMERICIDENTIFIER]}|${src[t$4.NUMERICIDENTIFIER]})`);
+	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t$4.NONNUMERICIDENTIFIER]}|${src[t$4.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASE", `(?:-(${src[t$4.PRERELEASEIDENTIFIER]}(?:\\.${src[t$4.PRERELEASEIDENTIFIER]})*))`);
+	createToken("PRERELEASELOOSE", `(?:-?(${src[t$4.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t$4.PRERELEASEIDENTIFIERLOOSE]})*))`);
+	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+	createToken("BUILD", `(?:\\+(${src[t$4.BUILDIDENTIFIER]}(?:\\.${src[t$4.BUILDIDENTIFIER]})*))`);
+	createToken("FULLPLAIN", `v?${src[t$4.MAINVERSION]}${src[t$4.PRERELEASE]}?${src[t$4.BUILD]}?`);
+	createToken("FULL", `^${src[t$4.FULLPLAIN]}$`);
+	createToken("LOOSEPLAIN", `[v=\\s]*${src[t$4.MAINVERSIONLOOSE]}${src[t$4.PRERELEASELOOSE]}?${src[t$4.BUILD]}?`);
+	createToken("LOOSE", `^${src[t$4.LOOSEPLAIN]}$`);
+	createToken("GTLT", "((?:<|>)?=?)");
+	createToken("XRANGEIDENTIFIERLOOSE", `${src[t$4.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+	createToken("XRANGEIDENTIFIER", `${src[t$4.NUMERICIDENTIFIER]}|x|X|\\*`);
+	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t$4.XRANGEIDENTIFIER]})(?:\\.(${src[t$4.XRANGEIDENTIFIER]})(?:\\.(${src[t$4.XRANGEIDENTIFIER]})(?:${src[t$4.PRERELEASE]})?${src[t$4.BUILD]}?)?)?`);
+	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t$4.XRANGEIDENTIFIERLOOSE]})(?:${src[t$4.PRERELEASELOOSE]})?${src[t$4.BUILD]}?)?)?`);
+	createToken("XRANGE", `^${src[t$4.GTLT]}\\s*${src[t$4.XRANGEPLAIN]}$`);
+	createToken("XRANGELOOSE", `^${src[t$4.GTLT]}\\s*${src[t$4.XRANGEPLAINLOOSE]}$`);
+	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken("COERCE", `${src[t$4.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken("COERCEFULL", src[t$4.COERCEPLAIN] + `(?:${src[t$4.PRERELEASE]})?(?:${src[t$4.BUILD]})?(?:$|[^\\d])`);
+	createToken("COERCERTL", src[t$4.COERCE], true);
+	createToken("COERCERTLFULL", src[t$4.COERCEFULL], true);
+	createToken("LONETILDE", "(?:~>?)");
+	createToken("TILDETRIM", `(\\s*)${src[t$4.LONETILDE]}\\s+`, true);
+	exports.tildeTrimReplace = "$1~";
+	createToken("TILDE", `^${src[t$4.LONETILDE]}${src[t$4.XRANGEPLAIN]}$`);
+	createToken("TILDELOOSE", `^${src[t$4.LONETILDE]}${src[t$4.XRANGEPLAINLOOSE]}$`);
+	createToken("LONECARET", "(?:\\^)");
+	createToken("CARETTRIM", `(\\s*)${src[t$4.LONECARET]}\\s+`, true);
+	exports.caretTrimReplace = "$1^";
+	createToken("CARET", `^${src[t$4.LONECARET]}${src[t$4.XRANGEPLAIN]}$`);
+	createToken("CARETLOOSE", `^${src[t$4.LONECARET]}${src[t$4.XRANGEPLAINLOOSE]}$`);
+	createToken("COMPARATORLOOSE", `^${src[t$4.GTLT]}\\s*(${src[t$4.LOOSEPLAIN]})$|^$`);
+	createToken("COMPARATOR", `^${src[t$4.GTLT]}\\s*(${src[t$4.FULLPLAIN]})$|^$`);
+	createToken("COMPARATORTRIM", `(\\s*)${src[t$4.GTLT]}\\s*(${src[t$4.LOOSEPLAIN]}|${src[t$4.XRANGEPLAIN]})`, true);
+	exports.comparatorTrimReplace = "$1$2$3";
+	createToken("HYPHENRANGE", `^\\s*(${src[t$4.XRANGEPLAIN]})\\s+-\\s+(${src[t$4.XRANGEPLAIN]})\\s*$`);
+	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t$4.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t$4.XRANGEPLAINLOOSE]})\\s*$`);
+	createToken("STAR", "(<|>)?=?\\s*\\*");
+	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js
+var require_parse_options = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js": ((exports, module) => {
+	const looseOption = Object.freeze({ loose: true });
+	const emptyOpts = Object.freeze({});
+	const parseOptions$3 = (options) => {
+		if (!options) return emptyOpts;
+		if (typeof options !== "object") return looseOption;
+		return options;
+	};
+	module.exports = parseOptions$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js
+var require_identifiers = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js": ((exports, module) => {
+	const numeric = /^[0-9]+$/;
+	const compareIdentifiers$1 = (a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+		const anum = numeric.test(a);
+		const bnum = numeric.test(b);
+		if (anum && bnum) {
+			a = +a;
+			b = +b;
+		}
+		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+	};
+	const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+	module.exports = {
+		compareIdentifiers: compareIdentifiers$1,
+		rcompareIdentifiers
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js
+var require_semver$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js": ((exports, module) => {
+	const debug$2 = require_debug();
+	const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+	const { safeRe: re$3, t: t$3 } = require_re();
+	const parseOptions$2 = require_parse_options();
+	const { compareIdentifiers } = require_identifiers();
+	var SemVer$15 = class SemVer$15 {
+		constructor(version$2, options) {
+			options = parseOptions$2(options);
+			if (version$2 instanceof SemVer$15) if (version$2.loose === !!options.loose && version$2.includePrerelease === !!options.includePrerelease) return version$2;
+			else version$2 = version$2.version;
+			else if (typeof version$2 !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version$2}".`);
+			if (version$2.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+			debug$2("SemVer", version$2, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			const m = version$2.trim().match(options.loose ? re$3[t$3.LOOSE] : re$3[t$3.FULL]);
+			if (!m) throw new TypeError(`Invalid Version: ${version$2}`);
+			this.raw = version$2;
+			this.major = +m[1];
+			this.minor = +m[2];
+			this.patch = +m[3];
+			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
+			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
+			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
+			if (!m[4]) this.prerelease = [];
+			else this.prerelease = m[4].split(".").map((id) => {
+				if (/^[0-9]+$/.test(id)) {
+					const num = +id;
+					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+				}
+				return id;
+			});
+			this.build = m[5] ? m[5].split(".") : [];
+			this.format();
+		}
+		format() {
+			this.version = `${this.major}.${this.minor}.${this.patch}`;
+			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+			return this.version;
+		}
+		toString() {
+			return this.version;
+		}
+		compare(other) {
+			debug$2("SemVer.compare", this.version, this.options, other);
+			if (!(other instanceof SemVer$15)) {
+				if (typeof other === "string" && other === this.version) return 0;
+				other = new SemVer$15(other, this.options);
+			}
+			if (other.version === this.version) return 0;
+			return this.compareMain(other) || this.comparePre(other);
+		}
+		compareMain(other) {
+			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
+			if (this.major < other.major) return -1;
+			if (this.major > other.major) return 1;
+			if (this.minor < other.minor) return -1;
+			if (this.minor > other.minor) return 1;
+			if (this.patch < other.patch) return -1;
+			if (this.patch > other.patch) return 1;
+			return 0;
+		}
+		comparePre(other) {
+			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
+			if (this.prerelease.length && !other.prerelease.length) return -1;
+			else if (!this.prerelease.length && other.prerelease.length) return 1;
+			else if (!this.prerelease.length && !other.prerelease.length) return 0;
+			let i$1 = 0;
+			do {
+				const a = this.prerelease[i$1];
+				const b = other.prerelease[i$1];
+				debug$2("prerelease compare", i$1, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i$1);
+		}
+		compareBuild(other) {
+			if (!(other instanceof SemVer$15)) other = new SemVer$15(other, this.options);
+			let i$1 = 0;
+			do {
+				const a = this.build[i$1];
+				const b = other.build[i$1];
+				debug$2("build compare", i$1, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i$1);
+		}
+		inc(release, identifier, identifierBase) {
+			if (release.startsWith("pre")) {
+				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
+				if (identifier) {
+					const match = `-${identifier}`.match(this.options.loose ? re$3[t$3.PRERELEASELOOSE] : re$3[t$3.PRERELEASE]);
+					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
+				}
+			}
+			switch (release) {
+				case "premajor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor = 0;
+					this.major++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "preminor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prepatch":
+					this.prerelease.length = 0;
+					this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prerelease":
+					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "release":
+					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
+					this.prerelease.length = 0;
+					break;
+				case "major":
+					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+					this.minor = 0;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "minor":
+					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "patch":
+					if (this.prerelease.length === 0) this.patch++;
+					this.prerelease = [];
+					break;
+				case "pre": {
+					const base = Number(identifierBase) ? 1 : 0;
+					if (this.prerelease.length === 0) this.prerelease = [base];
+					else {
+						let i$1 = this.prerelease.length;
+						while (--i$1 >= 0) if (typeof this.prerelease[i$1] === "number") {
+							this.prerelease[i$1]++;
+							i$1 = -2;
+						}
+						if (i$1 === -1) {
+							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
+							this.prerelease.push(base);
+						}
+					}
+					if (identifier) {
+						let prerelease$2 = [identifier, base];
+						if (identifierBase === false) prerelease$2 = [identifier];
+						if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+							if (isNaN(this.prerelease[1])) this.prerelease = prerelease$2;
+						} else this.prerelease = prerelease$2;
+					}
+					break;
+				}
+				default: throw new Error(`invalid increment argument: ${release}`);
+			}
+			this.raw = this.format();
+			if (this.build.length) this.raw += `+${this.build.join(".")}`;
+			return this;
+		}
+	};
+	module.exports = SemVer$15;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/parse.js
+var require_parse = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/parse.js": ((exports, module) => {
+	const SemVer$14 = require_semver$1();
+	const parse$6 = (version$2, options, throwErrors = false) => {
+		if (version$2 instanceof SemVer$14) return version$2;
+		try {
+			return new SemVer$14(version$2, options);
+		} catch (er) {
+			if (!throwErrors) return null;
+			throw er;
+		}
+	};
+	module.exports = parse$6;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/valid.js
+var require_valid$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/valid.js": ((exports, module) => {
+	const parse$5 = require_parse();
+	const valid$1 = (version$2, options) => {
+		const v = parse$5(version$2, options);
+		return v ? v.version : null;
+	};
+	module.exports = valid$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/clean.js
+var require_clean = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/clean.js": ((exports, module) => {
+	const parse$4 = require_parse();
+	const clean$1 = (version$2, options) => {
+		const s = parse$4(version$2.trim().replace(/^[=v]+/, ""), options);
+		return s ? s.version : null;
+	};
+	module.exports = clean$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/inc.js
+var require_inc = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/inc.js": ((exports, module) => {
+	const SemVer$13 = require_semver$1();
+	const inc$1 = (version$2, release, options, identifier, identifierBase) => {
+		if (typeof options === "string") {
+			identifierBase = identifier;
+			identifier = options;
+			options = void 0;
+		}
+		try {
+			return new SemVer$13(version$2 instanceof SemVer$13 ? version$2.version : version$2, options).inc(release, identifier, identifierBase).version;
+		} catch (er) {
+			return null;
+		}
+	};
+	module.exports = inc$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/diff.js
+var require_diff = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/diff.js": ((exports, module) => {
+	const parse$3 = require_parse();
+	const diff$1 = (version1, version2) => {
+		const v1 = parse$3(version1, null, true);
+		const v2 = parse$3(version2, null, true);
+		const comparison = v1.compare(v2);
+		if (comparison === 0) return null;
+		const v1Higher = comparison > 0;
+		const highVersion = v1Higher ? v1 : v2;
+		const lowVersion = v1Higher ? v2 : v1;
+		const highHasPre = !!highVersion.prerelease.length;
+		if (!!lowVersion.prerelease.length && !highHasPre) {
+			if (!lowVersion.patch && !lowVersion.minor) return "major";
+			if (lowVersion.compareMain(highVersion) === 0) {
+				if (lowVersion.minor && !lowVersion.patch) return "minor";
+				return "patch";
+			}
+		}
+		const prefix = highHasPre ? "pre" : "";
+		if (v1.major !== v2.major) return prefix + "major";
+		if (v1.minor !== v2.minor) return prefix + "minor";
+		if (v1.patch !== v2.patch) return prefix + "patch";
+		return "prerelease";
+	};
+	module.exports = diff$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/major.js
+var require_major = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/major.js": ((exports, module) => {
+	const SemVer$12 = require_semver$1();
+	const major$1 = (a, loose) => new SemVer$12(a, loose).major;
+	module.exports = major$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/minor.js
+var require_minor = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/minor.js": ((exports, module) => {
+	const SemVer$11 = require_semver$1();
+	const minor$1 = (a, loose) => new SemVer$11(a, loose).minor;
+	module.exports = minor$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/patch.js
+var require_patch = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/patch.js": ((exports, module) => {
+	const SemVer$10 = require_semver$1();
+	const patch$1 = (a, loose) => new SemVer$10(a, loose).patch;
+	module.exports = patch$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/prerelease.js
+var require_prerelease = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/prerelease.js": ((exports, module) => {
+	const parse$2 = require_parse();
+	const prerelease$1 = (version$2, options) => {
+		const parsed = parse$2(version$2, options);
+		return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+	};
+	module.exports = prerelease$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js
+var require_compare = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js": ((exports, module) => {
+	const SemVer$9 = require_semver$1();
+	const compare$11 = (a, b, loose) => new SemVer$9(a, loose).compare(new SemVer$9(b, loose));
+	module.exports = compare$11;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rcompare.js
+var require_rcompare = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rcompare.js": ((exports, module) => {
+	const compare$10 = require_compare();
+	const rcompare$1 = (a, b, loose) => compare$10(b, a, loose);
+	module.exports = rcompare$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-loose.js": ((exports, module) => {
+	const compare$9 = require_compare();
+	const compareLoose$1 = (a, b) => compare$9(a, b, true);
+	module.exports = compareLoose$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-build.js
+var require_compare_build = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-build.js": ((exports, module) => {
+	const SemVer$8 = require_semver$1();
+	const compareBuild$3 = (a, b, loose) => {
+		const versionA = new SemVer$8(a, loose);
+		const versionB = new SemVer$8(b, loose);
+		return versionA.compare(versionB) || versionA.compareBuild(versionB);
+	};
+	module.exports = compareBuild$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/sort.js
+var require_sort = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/sort.js": ((exports, module) => {
+	const compareBuild$2 = require_compare_build();
+	const sort$1 = (list$1, loose) => list$1.sort((a, b) => compareBuild$2(a, b, loose));
+	module.exports = sort$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rsort.js
+var require_rsort = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rsort.js": ((exports, module) => {
+	const compareBuild$1 = require_compare_build();
+	const rsort$1 = (list$1, loose) => list$1.sort((a, b) => compareBuild$1(b, a, loose));
+	module.exports = rsort$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gt.js
+var require_gt = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gt.js": ((exports, module) => {
+	const compare$8 = require_compare();
+	const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0;
+	module.exports = gt$4;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lt.js
+var require_lt = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lt.js": ((exports, module) => {
+	const compare$7 = require_compare();
+	const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0;
+	module.exports = lt$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/eq.js
+var require_eq = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/eq.js": ((exports, module) => {
+	const compare$6 = require_compare();
+	const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0;
+	module.exports = eq$2;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/neq.js
+var require_neq = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/neq.js": ((exports, module) => {
+	const compare$5 = require_compare();
+	const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0;
+	module.exports = neq$2;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js
+var require_gte = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js": ((exports, module) => {
+	const compare$4 = require_compare();
+	const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
+	module.exports = gte$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lte.js
+var require_lte = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lte.js": ((exports, module) => {
+	const compare$3 = require_compare();
+	const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
+	module.exports = lte$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/cmp.js
+var require_cmp = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/cmp.js": ((exports, module) => {
+	const eq$1 = require_eq();
+	const neq$1 = require_neq();
+	const gt$3 = require_gt();
+	const gte$2 = require_gte();
+	const lt$2 = require_lt();
+	const lte$2 = require_lte();
+	const cmp$2 = (a, op, b, loose) => {
+		switch (op) {
+			case "===":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a === b;
+			case "!==":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a !== b;
+			case "":
+			case "=":
+			case "==": return eq$1(a, b, loose);
+			case "!=": return neq$1(a, b, loose);
+			case ">": return gt$3(a, b, loose);
+			case ">=": return gte$2(a, b, loose);
+			case "<": return lt$2(a, b, loose);
+			case "<=": return lte$2(a, b, loose);
+			default: throw new TypeError(`Invalid operator: ${op}`);
+		}
+	};
+	module.exports = cmp$2;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/coerce.js
+var require_coerce = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/coerce.js": ((exports, module) => {
+	const SemVer$7 = require_semver$1();
+	const parse$1 = require_parse();
+	const { safeRe: re$2, t: t$2 } = require_re();
+	const coerce$2 = (version$2, options) => {
+		if (version$2 instanceof SemVer$7) return version$2;
+		if (typeof version$2 === "number") version$2 = String(version$2);
+		if (typeof version$2 !== "string") return null;
+		options = options || {};
+		let match = null;
+		if (!options.rtl) match = version$2.match(options.includePrerelease ? re$2[t$2.COERCEFULL] : re$2[t$2.COERCE]);
+		else {
+			const coerceRtlRegex = options.includePrerelease ? re$2[t$2.COERCERTLFULL] : re$2[t$2.COERCERTL];
+			let next;
+			while ((next = coerceRtlRegex.exec(version$2)) && (!match || match.index + match[0].length !== version$2.length)) {
+				if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+				coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+			}
+			coerceRtlRegex.lastIndex = -1;
+		}
+		if (match === null) return null;
+		const major$2 = match[2];
+		return parse$1(`${major$2}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, options);
+	};
+	module.exports = coerce$2;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/lrucache.js
+var require_lrucache = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/lrucache.js": ((exports, module) => {
+	var LRUCache = class {
+		constructor() {
+			this.max = 1e3;
+			this.map = /* @__PURE__ */ new Map();
+		}
+		get(key) {
+			const value = this.map.get(key);
+			if (value === void 0) return;
+			else {
+				this.map.delete(key);
+				this.map.set(key, value);
+				return value;
+			}
+		}
+		delete(key) {
+			return this.map.delete(key);
+		}
+		set(key, value) {
+			if (!this.delete(key) && value !== void 0) {
+				if (this.map.size >= this.max) {
+					const firstKey = this.map.keys().next().value;
+					this.delete(firstKey);
+				}
+				this.map.set(key, value);
+			}
+			return this;
+		}
+	};
+	module.exports = LRUCache;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/range.js
+var require_range = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/range.js": ((exports, module) => {
+	const SPACE_CHARACTERS = /\s+/g;
+	var Range$11 = class Range$11 {
+		constructor(range, options) {
+			options = parseOptions$1(options);
+			if (range instanceof Range$11) if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+			else return new Range$11(range.raw, options);
+			if (range instanceof Comparator$4) {
+				this.raw = range.value;
+				this.set = [[range]];
+				this.formatted = void 0;
+				return this;
+			}
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+			this.set = this.raw.split("||").map((r$1) => this.parseRange(r$1.trim())).filter((c) => c.length);
+			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+			if (this.set.length > 1) {
+				const first = this.set[0];
+				this.set = this.set.filter((c) => !isNullSet(c[0]));
+				if (this.set.length === 0) this.set = [first];
+				else if (this.set.length > 1) {
+					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
+						this.set = [c];
+						break;
+					}
+				}
+			}
+			this.formatted = void 0;
+		}
+		get range() {
+			if (this.formatted === void 0) {
+				this.formatted = "";
+				for (let i$1 = 0; i$1 < this.set.length; i$1++) {
+					if (i$1 > 0) this.formatted += "||";
+					const comps = this.set[i$1];
+					for (let k = 0; k < comps.length; k++) {
+						if (k > 0) this.formatted += " ";
+						this.formatted += comps[k].toString().trim();
+					}
+				}
+			}
+			return this.formatted;
+		}
+		format() {
+			return this.range;
+		}
+		toString() {
+			return this.range;
+		}
+		parseRange(range) {
+			const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
+			const cached = cache$1.get(memoKey);
+			if (cached) return cached;
+			const loose = this.options.loose;
+			const hr = loose ? re$1[t$1.HYPHENRANGELOOSE] : re$1[t$1.HYPHENRANGE];
+			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+			debug$1("hyphen replace", range);
+			range = range.replace(re$1[t$1.COMPARATORTRIM], comparatorTrimReplace);
+			debug$1("comparator trim", range);
+			range = range.replace(re$1[t$1.TILDETRIM], tildeTrimReplace);
+			debug$1("tilde trim", range);
+			range = range.replace(re$1[t$1.CARETTRIM], caretTrimReplace);
+			debug$1("caret trim", range);
+			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+			if (loose) rangeList = rangeList.filter((comp) => {
+				debug$1("loose invalid filter", comp, this.options);
+				return !!comp.match(re$1[t$1.COMPARATORLOOSE]);
+			});
+			debug$1("range list", rangeList);
+			const rangeMap = /* @__PURE__ */ new Map();
+			const comparators = rangeList.map((comp) => new Comparator$4(comp, this.options));
+			for (const comp of comparators) {
+				if (isNullSet(comp)) return [comp];
+				rangeMap.set(comp.value, comp);
+			}
+			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+			const result = [...rangeMap.values()];
+			cache$1.set(memoKey, result);
+			return result;
+		}
+		intersects(range, options) {
+			if (!(range instanceof Range$11)) throw new TypeError("a Range is required");
+			return this.set.some((thisComparators) => {
+				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+						return rangeComparators.every((rangeComparator) => {
+							return thisComparator.intersects(rangeComparator, options);
+						});
+					});
+				});
+			});
+		}
+		test(version$2) {
+			if (!version$2) return false;
+			if (typeof version$2 === "string") try {
+				version$2 = new SemVer$6(version$2, this.options);
+			} catch (er) {
+				return false;
+			}
+			for (let i$1 = 0; i$1 < this.set.length; i$1++) if (testSet(this.set[i$1], version$2, this.options)) return true;
+			return false;
+		}
+	};
+	module.exports = Range$11;
+	const cache$1 = new (require_lrucache())();
+	const parseOptions$1 = require_parse_options();
+	const Comparator$4 = require_comparator();
+	const debug$1 = require_debug();
+	const SemVer$6 = require_semver$1();
+	const { safeRe: re$1, t: t$1, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+	const isNullSet = (c) => c.value === "<0.0.0-0";
+	const isAny = (c) => c.value === "";
+	const isSatisfiable = (comparators, options) => {
+		let result = true;
+		const remainingComparators = comparators.slice();
+		let testComparator = remainingComparators.pop();
+		while (result && remainingComparators.length) {
+			result = remainingComparators.every((otherComparator) => {
+				return testComparator.intersects(otherComparator, options);
+			});
+			testComparator = remainingComparators.pop();
+		}
+		return result;
+	};
+	const parseComparator = (comp, options) => {
+		comp = comp.replace(re$1[t$1.BUILD], "");
+		debug$1("comp", comp, options);
+		comp = replaceCarets(comp, options);
+		debug$1("caret", comp);
+		comp = replaceTildes(comp, options);
+		debug$1("tildes", comp);
+		comp = replaceXRanges(comp, options);
+		debug$1("xrange", comp);
+		comp = replaceStars(comp, options);
+		debug$1("stars", comp);
+		return comp;
+	};
+	const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+	const replaceTildes = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+	};
+	const replaceTilde = (comp, options) => {
+		const r$1 = options.loose ? re$1[t$1.TILDELOOSE] : re$1[t$1.TILDE];
+		return comp.replace(r$1, (_, M, m, p, pr) => {
+			debug$1("tilde", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+			else if (isX(p)) ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+			else if (pr) {
+				debug$1("replaceTilde pr", pr);
+				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+			debug$1("tilde return", ret);
+			return ret;
+		});
+	};
+	const replaceCarets = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+	};
+	const replaceCaret = (comp, options) => {
+		debug$1("caret", comp, options);
+		const r$1 = options.loose ? re$1[t$1.CARETLOOSE] : re$1[t$1.CARET];
+		const z$1 = options.includePrerelease ? "-0" : "";
+		return comp.replace(r$1, (_, M, m, p, pr) => {
+			debug$1("caret", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z$1} <${+M + 1}.0.0-0`;
+			else if (isX(p)) if (M === "0") ret = `>=${M}.${m}.0${z$1} <${M}.${+m + 1}.0-0`;
+			else ret = `>=${M}.${m}.0${z$1} <${+M + 1}.0.0-0`;
+			else if (pr) {
+				debug$1("replaceCaret pr", pr);
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+			} else {
+				debug$1("no pr");
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}${z$1} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p}${z$1} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+			}
+			debug$1("caret return", ret);
+			return ret;
+		});
+	};
+	const replaceXRanges = (comp, options) => {
+		debug$1("replaceXRanges", comp, options);
+		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+	};
+	const replaceXRange = (comp, options) => {
+		comp = comp.trim();
+		const r$1 = options.loose ? re$1[t$1.XRANGELOOSE] : re$1[t$1.XRANGE];
+		return comp.replace(r$1, (ret, gtlt, M, m, p, pr) => {
+			debug$1("xRange", comp, ret, gtlt, M, m, p, pr);
+			const xM = isX(M);
+			const xm = xM || isX(m);
+			const xp = xm || isX(p);
+			const anyX = xp;
+			if (gtlt === "=" && anyX) gtlt = "";
+			pr = options.includePrerelease ? "-0" : "";
+			if (xM) if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+			else ret = "*";
+			else if (gtlt && anyX) {
+				if (xm) m = 0;
+				p = 0;
+				if (gtlt === ">") {
+					gtlt = ">=";
+					if (xm) {
+						M = +M + 1;
+						m = 0;
+						p = 0;
+					} else {
+						m = +m + 1;
+						p = 0;
+					}
+				} else if (gtlt === "<=") {
+					gtlt = "<";
+					if (xm) M = +M + 1;
+					else m = +m + 1;
+				}
+				if (gtlt === "<") pr = "-0";
+				ret = `${gtlt + M}.${m}.${p}${pr}`;
+			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+			debug$1("xRange return", ret);
+			return ret;
+		});
+	};
+	const replaceStars = (comp, options) => {
+		debug$1("replaceStars", comp, options);
+		return comp.trim().replace(re$1[t$1.STAR], "");
+	};
+	const replaceGTE0 = (comp, options) => {
+		debug$1("replaceGTE0", comp, options);
+		return comp.trim().replace(re$1[options.includePrerelease ? t$1.GTE0PRE : t$1.GTE0], "");
+	};
+	const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+		if (isX(fM)) from = "";
+		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+		else if (fpr) from = `>=${from}`;
+		else from = `>=${from}${incPr ? "-0" : ""}`;
+		if (isX(tM)) to = "";
+		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
+		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
+		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
+		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	};
+	const testSet = (set, version$2, options) => {
+		for (let i$1 = 0; i$1 < set.length; i$1++) if (!set[i$1].test(version$2)) return false;
+		if (version$2.prerelease.length && !options.includePrerelease) {
+			for (let i$1 = 0; i$1 < set.length; i$1++) {
+				debug$1(set[i$1].semver);
+				if (set[i$1].semver === Comparator$4.ANY) continue;
+				if (set[i$1].semver.prerelease.length > 0) {
+					const allowed = set[i$1].semver;
+					if (allowed.major === version$2.major && allowed.minor === version$2.minor && allowed.patch === version$2.patch) return true;
+				}
+			}
+			return false;
+		}
+		return true;
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/comparator.js
+var require_comparator = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/comparator.js": ((exports, module) => {
+	const ANY$2 = Symbol("SemVer ANY");
+	var Comparator$3 = class Comparator$3 {
+		static get ANY() {
+			return ANY$2;
+		}
+		constructor(comp, options) {
+			options = parseOptions(options);
+			if (comp instanceof Comparator$3) if (comp.loose === !!options.loose) return comp;
+			else comp = comp.value;
+			comp = comp.trim().split(/\s+/).join(" ");
+			debug("comparator", comp, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.parse(comp);
+			if (this.semver === ANY$2) this.value = "";
+			else this.value = this.operator + this.semver.version;
+			debug("comp", this);
+		}
+		parse(comp) {
+			const r$1 = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+			const m = comp.match(r$1);
+			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+			this.operator = m[1] !== void 0 ? m[1] : "";
+			if (this.operator === "=") this.operator = "";
+			if (!m[2]) this.semver = ANY$2;
+			else this.semver = new SemVer$5(m[2], this.options.loose);
+		}
+		toString() {
+			return this.value;
+		}
+		test(version$2) {
+			debug("Comparator.test", version$2, this.options.loose);
+			if (this.semver === ANY$2 || version$2 === ANY$2) return true;
+			if (typeof version$2 === "string") try {
+				version$2 = new SemVer$5(version$2, this.options);
+			} catch (er) {
+				return false;
+			}
+			return cmp$1(version$2, this.operator, this.semver, this.options);
+		}
+		intersects(comp, options) {
+			if (!(comp instanceof Comparator$3)) throw new TypeError("a Comparator is required");
+			if (this.operator === "") {
+				if (this.value === "") return true;
+				return new Range$10(comp.value, options).test(this.value);
+			} else if (comp.operator === "") {
+				if (comp.value === "") return true;
+				return new Range$10(this.value, options).test(comp.semver);
+			}
+			options = parseOptions(options);
+			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
+			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+			if (cmp$1(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+			if (cmp$1(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+			return false;
+		}
+	};
+	module.exports = Comparator$3;
+	const parseOptions = require_parse_options();
+	const { safeRe: re, t } = require_re();
+	const cmp$1 = require_cmp();
+	const debug = require_debug();
+	const SemVer$5 = require_semver$1();
+	const Range$10 = require_range();
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/satisfies.js
+var require_satisfies = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/satisfies.js": ((exports, module) => {
+	const Range$9 = require_range();
+	const satisfies$5 = (version$2, range, options) => {
+		try {
+			range = new Range$9(range, options);
+		} catch (er) {
+			return false;
+		}
+		return range.test(version$2);
+	};
+	module.exports = satisfies$5;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/to-comparators.js": ((exports, module) => {
+	const Range$8 = require_range();
+	const toComparators$1 = (range, options) => new Range$8(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+	module.exports = toComparators$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/max-satisfying.js": ((exports, module) => {
+	const SemVer$4 = require_semver$1();
+	const Range$7 = require_range();
+	const maxSatisfying$1 = (versions, range, options) => {
+		let max = null;
+		let maxSV = null;
+		let rangeObj = null;
+		try {
+			rangeObj = new Range$7(range, options);
+		} catch (er) {
+			return null;
+		}
+		versions.forEach((v) => {
+			if (rangeObj.test(v)) {
+				if (!max || maxSV.compare(v) === -1) {
+					max = v;
+					maxSV = new SemVer$4(max, options);
+				}
+			}
+		});
+		return max;
+	};
+	module.exports = maxSatisfying$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-satisfying.js": ((exports, module) => {
+	const SemVer$3 = require_semver$1();
+	const Range$6 = require_range();
+	const minSatisfying$1 = (versions, range, options) => {
+		let min = null;
+		let minSV = null;
+		let rangeObj = null;
+		try {
+			rangeObj = new Range$6(range, options);
+		} catch (er) {
+			return null;
+		}
+		versions.forEach((v) => {
+			if (rangeObj.test(v)) {
+				if (!min || minSV.compare(v) === 1) {
+					min = v;
+					minSV = new SemVer$3(min, options);
+				}
+			}
+		});
+		return min;
+	};
+	module.exports = minSatisfying$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-version.js
+var require_min_version = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-version.js": ((exports, module) => {
+	const SemVer$2 = require_semver$1();
+	const Range$5 = require_range();
+	const gt$2 = require_gt();
+	const minVersion$1 = (range, loose) => {
+		range = new Range$5(range, loose);
+		let minver = new SemVer$2("0.0.0");
+		if (range.test(minver)) return minver;
+		minver = new SemVer$2("0.0.0-0");
+		if (range.test(minver)) return minver;
+		minver = null;
+		for (let i$1 = 0; i$1 < range.set.length; ++i$1) {
+			const comparators = range.set[i$1];
+			let setMin = null;
+			comparators.forEach((comparator) => {
+				const compver = new SemVer$2(comparator.semver.version);
+				switch (comparator.operator) {
+					case ">":
+						if (compver.prerelease.length === 0) compver.patch++;
+						else compver.prerelease.push(0);
+						compver.raw = compver.format();
+					case "":
+					case ">=":
+						if (!setMin || gt$2(compver, setMin)) setMin = compver;
+						break;
+					case "<":
+					case "<=": break;
+					default: throw new Error(`Unexpected operation: ${comparator.operator}`);
+				}
+			});
+			if (setMin && (!minver || gt$2(minver, setMin))) minver = setMin;
+		}
+		if (minver && range.test(minver)) return minver;
+		return null;
+	};
+	module.exports = minVersion$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/valid.js
+var require_valid = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/valid.js": ((exports, module) => {
+	const Range$4 = require_range();
+	const validRange$1 = (range, options) => {
+		try {
+			return new Range$4(range, options).range || "*";
+		} catch (er) {
+			return null;
+		}
+	};
+	module.exports = validRange$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/outside.js
+var require_outside = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/outside.js": ((exports, module) => {
+	const SemVer$1 = require_semver$1();
+	const Comparator$2 = require_comparator();
+	const { ANY: ANY$1 } = Comparator$2;
+	const Range$3 = require_range();
+	const satisfies$4 = require_satisfies();
+	const gt$1 = require_gt();
+	const lt$1 = require_lt();
+	const lte$1 = require_lte();
+	const gte$1 = require_gte();
+	const outside$3 = (version$2, range, hilo, options) => {
+		version$2 = new SemVer$1(version$2, options);
+		range = new Range$3(range, options);
+		let gtfn, ltefn, ltfn, comp, ecomp;
+		switch (hilo) {
+			case ">":
+				gtfn = gt$1;
+				ltefn = lte$1;
+				ltfn = lt$1;
+				comp = ">";
+				ecomp = ">=";
+				break;
+			case "<":
+				gtfn = lt$1;
+				ltefn = gte$1;
+				ltfn = gt$1;
+				comp = "<";
+				ecomp = "<=";
+				break;
+			default: throw new TypeError("Must provide a hilo val of \"<\" or \">\"");
+		}
+		if (satisfies$4(version$2, range, options)) return false;
+		for (let i$1 = 0; i$1 < range.set.length; ++i$1) {
+			const comparators = range.set[i$1];
+			let high = null;
+			let low = null;
+			comparators.forEach((comparator) => {
+				if (comparator.semver === ANY$1) comparator = new Comparator$2(">=0.0.0");
+				high = high || comparator;
+				low = low || comparator;
+				if (gtfn(comparator.semver, high.semver, options)) high = comparator;
+				else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
+			});
+			if (high.operator === comp || high.operator === ecomp) return false;
+			if ((!low.operator || low.operator === comp) && ltefn(version$2, low.semver)) return false;
+			else if (low.operator === ecomp && ltfn(version$2, low.semver)) return false;
+		}
+		return true;
+	};
+	module.exports = outside$3;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/gtr.js
+var require_gtr = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/gtr.js": ((exports, module) => {
+	const outside$2 = require_outside();
+	const gtr$1 = (version$2, range, options) => outside$2(version$2, range, ">", options);
+	module.exports = gtr$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/ltr.js
+var require_ltr = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/ltr.js": ((exports, module) => {
+	const outside$1 = require_outside();
+	const ltr$1 = (version$2, range, options) => outside$1(version$2, range, "<", options);
+	module.exports = ltr$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/intersects.js
+var require_intersects = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/intersects.js": ((exports, module) => {
+	const Range$2 = require_range();
+	const intersects$1 = (r1, r2, options) => {
+		r1 = new Range$2(r1, options);
+		r2 = new Range$2(r2, options);
+		return r1.intersects(r2, options);
+	};
+	module.exports = intersects$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/simplify.js
+var require_simplify = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/simplify.js": ((exports, module) => {
+	const satisfies$3 = require_satisfies();
+	const compare$2 = require_compare();
+	module.exports = (versions, range, options) => {
+		const set = [];
+		let first = null;
+		let prev = null;
+		const v = versions.sort((a, b) => compare$2(a, b, options));
+		for (const version$2 of v) if (satisfies$3(version$2, range, options)) {
+			prev = version$2;
+			if (!first) first = version$2;
+		} else {
+			if (prev) set.push([first, prev]);
+			prev = null;
+			first = null;
+		}
+		if (first) set.push([first, null]);
+		const ranges = [];
+		for (const [min, max] of set) if (min === max) ranges.push(min);
+		else if (!max && min === v[0]) ranges.push("*");
+		else if (!max) ranges.push(`>=${min}`);
+		else if (min === v[0]) ranges.push(`<=${max}`);
+		else ranges.push(`${min} - ${max}`);
+		const simplified = ranges.join(" || ");
+		const original = typeof range.raw === "string" ? range.raw : String(range);
+		return simplified.length < original.length ? simplified : range;
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/subset.js
+var require_subset = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/subset.js": ((exports, module) => {
+	const Range$1 = require_range();
+	const Comparator$1 = require_comparator();
+	const { ANY } = Comparator$1;
+	const satisfies$2 = require_satisfies();
+	const compare$1 = require_compare();
+	const subset$1 = (sub, dom, options = {}) => {
+		if (sub === dom) return true;
+		sub = new Range$1(sub, options);
+		dom = new Range$1(dom, options);
+		let sawNonNull = false;
+		OUTER: for (const simpleSub of sub.set) {
+			for (const simpleDom of dom.set) {
+				const isSub = simpleSubset(simpleSub, simpleDom, options);
+				sawNonNull = sawNonNull || isSub !== null;
+				if (isSub) continue OUTER;
+			}
+			if (sawNonNull) return false;
+		}
+		return true;
+	};
+	const minimumVersionWithPreRelease = [new Comparator$1(">=0.0.0-0")];
+	const minimumVersion = [new Comparator$1(">=0.0.0")];
+	const simpleSubset = (sub, dom, options) => {
+		if (sub === dom) return true;
+		if (sub.length === 1 && sub[0].semver === ANY) if (dom.length === 1 && dom[0].semver === ANY) return true;
+		else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
+		else sub = minimumVersion;
+		if (dom.length === 1 && dom[0].semver === ANY) if (options.includePrerelease) return true;
+		else dom = minimumVersion;
+		const eqSet = /* @__PURE__ */ new Set();
+		let gt$5, lt$4;
+		for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt$5 = higherGT(gt$5, c, options);
+		else if (c.operator === "<" || c.operator === "<=") lt$4 = lowerLT(lt$4, c, options);
+		else eqSet.add(c.semver);
+		if (eqSet.size > 1) return null;
+		let gtltComp;
+		if (gt$5 && lt$4) {
+			gtltComp = compare$1(gt$5.semver, lt$4.semver, options);
+			if (gtltComp > 0) return null;
+			else if (gtltComp === 0 && (gt$5.operator !== ">=" || lt$4.operator !== "<=")) return null;
+		}
+		for (const eq$3 of eqSet) {
+			if (gt$5 && !satisfies$2(eq$3, String(gt$5), options)) return null;
+			if (lt$4 && !satisfies$2(eq$3, String(lt$4), options)) return null;
+			for (const c of dom) if (!satisfies$2(eq$3, String(c), options)) return false;
+			return true;
+		}
+		let higher, lower;
+		let hasDomLT, hasDomGT;
+		let needDomLTPre = lt$4 && !options.includePrerelease && lt$4.semver.prerelease.length ? lt$4.semver : false;
+		let needDomGTPre = gt$5 && !options.includePrerelease && gt$5.semver.prerelease.length ? gt$5.semver : false;
+		if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt$4.operator === "<" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;
+		for (const c of dom) {
+			hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+			hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+			if (gt$5) {
+				if (needDomGTPre) {
+					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
+				}
+				if (c.operator === ">" || c.operator === ">=") {
+					higher = higherGT(gt$5, c, options);
+					if (higher === c && higher !== gt$5) return false;
+				} else if (gt$5.operator === ">=" && !satisfies$2(gt$5.semver, String(c), options)) return false;
+			}
+			if (lt$4) {
+				if (needDomLTPre) {
+					if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
+				}
+				if (c.operator === "<" || c.operator === "<=") {
+					lower = lowerLT(lt$4, c, options);
+					if (lower === c && lower !== lt$4) return false;
+				} else if (lt$4.operator === "<=" && !satisfies$2(lt$4.semver, String(c), options)) return false;
+			}
+			if (!c.operator && (lt$4 || gt$5) && gtltComp !== 0) return false;
+		}
+		if (gt$5 && hasDomLT && !lt$4 && gtltComp !== 0) return false;
+		if (lt$4 && hasDomGT && !gt$5 && gtltComp !== 0) return false;
+		if (needDomGTPre || needDomLTPre) return false;
+		return true;
+	};
+	const higherGT = (a, b, options) => {
+		if (!a) return b;
+		const comp = compare$1(a.semver, b.semver, options);
+		return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+	};
+	const lowerLT = (a, b, options) => {
+		if (!a) return b;
+		const comp = compare$1(a.semver, b.semver, options);
+		return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+	};
+	module.exports = subset$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js
+var require_semver = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js": ((exports, module) => {
+	const internalRe = require_re();
+	const constants = require_constants();
+	const SemVer = require_semver$1();
+	const identifiers = require_identifiers();
+	const parse = require_parse();
+	const valid = require_valid$1();
+	const clean = require_clean();
+	const inc = require_inc();
+	const diff = require_diff();
+	const major = require_major();
+	const minor = require_minor();
+	const patch = require_patch();
+	const prerelease = require_prerelease();
+	const compare = require_compare();
+	const rcompare = require_rcompare();
+	const compareLoose = require_compare_loose();
+	const compareBuild = require_compare_build();
+	const sort = require_sort();
+	const rsort = require_rsort();
+	const gt = require_gt();
+	const lt = require_lt();
+	const eq = require_eq();
+	const neq = require_neq();
+	const gte = require_gte();
+	const lte = require_lte();
+	const cmp = require_cmp();
+	const coerce$1 = require_coerce();
+	const Comparator = require_comparator();
+	const Range = require_range();
+	const satisfies$1 = require_satisfies();
+	const toComparators = require_to_comparators();
+	const maxSatisfying = require_max_satisfying();
+	const minSatisfying = require_min_satisfying();
+	const minVersion = require_min_version();
+	const validRange = require_valid();
+	const outside = require_outside();
+	const gtr = require_gtr();
+	const ltr = require_ltr();
+	const intersects = require_intersects();
+	const simplifyRange = require_simplify();
+	const subset = require_subset();
+	module.exports = {
+		parse,
+		valid,
+		clean,
+		inc,
+		diff,
+		major,
+		minor,
+		patch,
+		prerelease,
+		compare,
+		rcompare,
+		compareLoose,
+		compareBuild,
+		sort,
+		rsort,
+		gt,
+		lt,
+		eq,
+		neq,
+		gte,
+		lte,
+		cmp,
+		coerce: coerce$1,
+		Comparator,
+		Range,
+		satisfies: satisfies$1,
+		toComparators,
+		maxSatisfying,
+		minSatisfying,
+		minVersion,
+		validRange,
+		outside,
+		gtr,
+		ltr,
+		intersects,
+		simplifyRange,
+		subset,
+		SemVer,
+		re: internalRe.re,
+		src: internalRe.src,
+		tokens: internalRe.t,
+		SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+		RELEASE_TYPES: constants.RELEASE_TYPES,
+		compareIdentifiers: identifiers.compareIdentifiers,
+		rcompareIdentifiers: identifiers.rcompareIdentifiers
+	};
+}) });
+
+//#endregion
+//#region src/assert-wrangler-version.ts
+var import_semver = require_semver();
+/**
+* Asserts that the installed version of Wrangler that gets pulled in at runtime by the `@cloudflare/vite-plugin`
+* matches the version that `@cloudflare/vite-plugin` actually depends upon.
+*
+* This can sometime be broken by package managers that deduplicate dependencies, such as `pnpm`.
+*/
+async function assertWranglerVersion() {
+	const installedVersion = (await import("wrangler/package.json", { with: { type: "json" } })).default.version;
+	const peerDependency = (await import("../package.json", { with: { type: "json" } })).default.peerDependencies.wrangler;
+	if (peerDependency.startsWith("workspace:")) return;
+	if (!(0, import_semver.satisfies)(installedVersion, peerDependency)) throw new Error(`The installed version of Wrangler (${installedVersion}) does not satisfy the peer dependency required by @cloudflare/vite-plugin (${peerDependency}).\nPlease install wrangler@${peerDependency}.`);
+}
+
 //#endregion
 //#region src/utils.ts
+var import_gte = /* @__PURE__ */ __toESM(require_gte(), 1);
 const debuglog = util$1.debuglog("@cloudflare:vite-plugin");
 /**
 * Creates an internal plugin to be used inside the main `vite-plugin-cloudflare` plugin.
@@ -67,14 +1511,14 @@ function createPlugin(name, pluginFactory) {
 }
 function getOutputDirectory(userConfig, environmentName) {
 	const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-	return userConfig.environments?.[environmentName]?.build?.outDir ?? path$1.join(rootOutputDirectory, environmentName);
+	return userConfig.environments?.[environmentName]?.build?.outDir ?? nodePath.join(rootOutputDirectory, environmentName);
 }
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
 	return url.replace(postfixRE, "");
 }
-function withTrailingSlash(path$2) {
-	return path$2.endsWith("/") ? path$2 : `${path$2}/`;
+function withTrailingSlash(path$1) {
+	return path$1.endsWith("/") ? path$1 : `${path$1}/`;
 }
 function createRequestHandler(handler) {
 	return async (req, res, next) => {
@@ -94,6 +1538,9 @@ function createRequestHandler(handler) {
 		}
 	};
 }
+function satisfiesViteVersion(minVersion$2) {
+	return (0, import_gte.default)(version, minVersion$2);
+}
 function toMiniflareRequest(request$1) {
 	const host = request$1.headers.get("Host");
 	const xForwardedHost = request$1.headers.get("X-Forwarded-Host");
@@ -117,7 +1564,7 @@ function getWorkerNameToWorkerEntrypointExportsMap(workers) {
 	return workerNameToWorkerEntrypointExportsMap;
 }
 function getWorkerNameToDurableObjectExportsMap(workers) {
-	const workerNameToDurableObjectExportsMap = new Map(workers.map((worker) => [worker.config.name, new Set(unstable_getDurableObjectClassNameToUseSQLiteMap(worker.config.migrations).keys())]));
+	const workerNameToDurableObjectExportsMap = new Map(workers.map((worker) => [worker.config.name, new Set(wrangler.unstable_getDurableObjectClassNameToUseSQLiteMap(worker.config.migrations).keys())]));
 	for (const worker of workers) for (const value of worker.config.durable_objects.bindings) if (value.script_name) workerNameToDurableObjectExportsMap.get(value.script_name)?.add(value.class_name);
 	else workerNameToDurableObjectExportsMap.get(worker.config.name)?.add(value.class_name);
 	return workerNameToDurableObjectExportsMap;
@@ -266,6 +1713,13 @@ var PluginContext = class {
 	getWorkerConfig(environmentName) {
 		return this.resolvedPluginConfig.type === "workers" ? this.resolvedPluginConfig.environmentNameToWorkerMap.get(environmentName)?.config : void 0;
 	}
+	get allWorkerConfigs() {
+		switch (this.resolvedPluginConfig.type) {
+			case "workers": return Array.from(this.resolvedPluginConfig.environmentNameToWorkerMap.values()).map((worker) => worker.config);
+			case "preview": return this.resolvedPluginConfig.workers;
+			default: return [];
+		}
+	}
 	get entryWorkerConfig() {
 		if (this.resolvedPluginConfig.type !== "workers") return;
 		return this.resolvedPluginConfig.environmentNameToWorkerMap.get(this.resolvedPluginConfig.entryWorkerEnvironmentName)?.config;
@@ -356,21 +1810,22 @@ const formatInvalidRoutes = (invalidRules) => {
 //#endregion
 //#region src/deploy-config.ts
 function getDeployConfigPath(root) {
-	return path$1.resolve(root, ".wrangler", "deploy", "config.json");
+	return nodePath.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root) {
 	const deployConfigPath = getDeployConfigPath(root);
 	const deployConfig = JSON.parse(fs$1.readFileSync(deployConfigPath, "utf-8"));
 	return [{ configPath: deployConfig.configPath }, ...deployConfig.auxiliaryWorkers].map(({ configPath }) => {
-		return unstable_readConfig({ config: path$1.resolve(path$1.dirname(deployConfigPath), configPath) });
+		const resolvedConfigPath = nodePath.resolve(nodePath.dirname(deployConfigPath), configPath);
+		return wrangler.unstable_readConfig({ config: resolvedConfigPath });
 	});
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-	return path$1.relative(deployConfigDirectory, path$1.resolve(root, outputDirectory, "wrangler.json"));
+	return nodePath.relative(deployConfigDirectory, nodePath.resolve(root, outputDirectory, "wrangler.json"));
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 	const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-	const deployConfigDirectory = path$1.dirname(deployConfigPath);
+	const deployConfigDirectory = nodePath.dirname(deployConfigPath);
 	fs$1.mkdirSync(deployConfigDirectory, { recursive: true });
 	if (resolvedPluginConfig.type === "assets-only") {
 		const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
@@ -1700,7 +3155,7 @@ var prototypeAccessors = {
 	allowNewDotTarget: { configurable: true },
 	inClassStaticBlock: { configurable: true }
 };
-Parser.prototype.parse = function parse() {
+Parser.prototype.parse = function parse$7() {
 	var node = this.options.program || this.startNode();
 	this.nextToken();
 	return this.parseTopLevel(node);
@@ -1750,7 +3205,7 @@ Parser.extend = function extend() {
 	for (var i$1 = 0; i$1 < plugins.length; i$1++) cls = plugins[i$1](cls);
 	return cls;
 };
-Parser.parse = function parse(input, options) {
+Parser.parse = function parse$7(input, options) {
 	return new this(options, input).parse();
 };
 Parser.parseExpressionAt = function parseExpressionAt(input, pos, options) {
@@ -1852,10 +3307,10 @@ pp$9.isSimpleAssignTarget = function(expr) {
 };
 var pp$8 = Parser.prototype;
 pp$8.parseTopLevel = function(node) {
-	var exports = Object.create(null);
+	var exports$1 = Object.create(null);
 	if (!node.body) node.body = [];
 	while (this.type !== types$1$1.eof) {
-		var stmt = this.parseStatement(null, true, exports);
+		var stmt = this.parseStatement(null, true, exports$1);
 		node.body.push(stmt);
 	}
 	if (this.inModule) for (var i$1 = 0, list$1 = Object.keys(this.undefinedExports); i$1 < list$1.length; i$1 += 1) {
@@ -1892,7 +3347,7 @@ pp$8.isAsyncFunction = function() {
 	var next = this.pos + skip[0].length, after;
 	return !lineBreak.test(this.input.slice(this.pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 === this.input.length || !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 55295 && after < 56320));
 };
-pp$8.parseStatement = function(context, topLevel, exports) {
+pp$8.parseStatement = function(context, topLevel, exports$1) {
 	var starttype = this.type, node = this.startNode(), kind;
 	if (this.isLet(context)) {
 		starttype = types$1$1._var;
@@ -1936,7 +3391,7 @@ pp$8.parseStatement = function(context, topLevel, exports) {
 				if (!topLevel) this.raise(this.start, "'import' and 'export' may only appear at the top level");
 				if (!this.inModule) this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
 			}
-			return starttype === types$1$1._import ? this.parseImport(node) : this.parseExport(node, exports);
+			return starttype === types$1$1._import ? this.parseImport(node) : this.parseExport(node, exports$1);
 		default:
 			if (this.isAsyncFunction()) {
 				if (context) this.unexpected();
@@ -2425,10 +3880,10 @@ function checkKeyName(node, name) {
 	var key = node.key;
 	return !computed && (key.type === "Identifier" && key.name === name || key.type === "Literal" && key.value === name);
 }
-pp$8.parseExportAllDeclaration = function(node, exports) {
+pp$8.parseExportAllDeclaration = function(node, exports$1) {
 	if (this.options.ecmaVersion >= 11) if (this.eatContextual("as")) {
 		node.exported = this.parseModuleExportName();
-		this.checkExport(exports, node.exported, this.lastTokStart);
+		this.checkExport(exports$1, node.exported, this.lastTokStart);
 	} else node.exported = null;
 	this.expectContextual("from");
 	if (this.type !== types$1$1.string) this.unexpected();
@@ -2437,23 +3892,23 @@ pp$8.parseExportAllDeclaration = function(node, exports) {
 	this.semicolon();
 	return this.finishNode(node, "ExportAllDeclaration");
 };
-pp$8.parseExport = function(node, exports) {
+pp$8.parseExport = function(node, exports$1) {
 	this.next();
-	if (this.eat(types$1$1.star)) return this.parseExportAllDeclaration(node, exports);
+	if (this.eat(types$1$1.star)) return this.parseExportAllDeclaration(node, exports$1);
 	if (this.eat(types$1$1._default)) {
-		this.checkExport(exports, "default", this.lastTokStart);
+		this.checkExport(exports$1, "default", this.lastTokStart);
 		node.declaration = this.parseExportDefaultDeclaration();
 		return this.finishNode(node, "ExportDefaultDeclaration");
 	}
 	if (this.shouldParseExportStatement()) {
 		node.declaration = this.parseExportDeclaration(node);
-		if (node.declaration.type === "VariableDeclaration") this.checkVariableExport(exports, node.declaration.declarations);
-		else this.checkExport(exports, node.declaration.id, node.declaration.id.start);
+		if (node.declaration.type === "VariableDeclaration") this.checkVariableExport(exports$1, node.declaration.declarations);
+		else this.checkExport(exports$1, node.declaration.id, node.declaration.id.start);
 		node.specifiers = [];
 		node.source = null;
 	} else {
 		node.declaration = null;
-		node.specifiers = this.parseExportSpecifiers(exports);
+		node.specifiers = this.parseExportSpecifiers(exports$1);
 		if (this.eatContextual("from")) {
 			if (this.type !== types$1$1.string) this.unexpected();
 			node.source = this.parseExprAtom();
@@ -2490,45 +3945,45 @@ pp$8.parseExportDefaultDeclaration = function() {
 		return declaration;
 	}
 };
-pp$8.checkExport = function(exports, name, pos) {
-	if (!exports) return;
+pp$8.checkExport = function(exports$1, name, pos) {
+	if (!exports$1) return;
 	if (typeof name !== "string") name = name.type === "Identifier" ? name.name : name.value;
-	if (hasOwn(exports, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
-	exports[name] = true;
+	if (hasOwn(exports$1, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
+	exports$1[name] = true;
 };
-pp$8.checkPatternExport = function(exports, pat) {
+pp$8.checkPatternExport = function(exports$1, pat) {
 	var type = pat.type;
-	if (type === "Identifier") this.checkExport(exports, pat, pat.start);
+	if (type === "Identifier") this.checkExport(exports$1, pat, pat.start);
 	else if (type === "ObjectPattern") for (var i$1 = 0, list$1 = pat.properties; i$1 < list$1.length; i$1 += 1) {
 		var prop = list$1[i$1];
-		this.checkPatternExport(exports, prop);
+		this.checkPatternExport(exports$1, prop);
 	}
 	else if (type === "ArrayPattern") for (var i$1$1 = 0, list$1$1 = pat.elements; i$1$1 < list$1$1.length; i$1$1 += 1) {
 		var elt = list$1$1[i$1$1];
-		if (elt) this.checkPatternExport(exports, elt);
+		if (elt) this.checkPatternExport(exports$1, elt);
 	}
-	else if (type === "Property") this.checkPatternExport(exports, pat.value);
-	else if (type === "AssignmentPattern") this.checkPatternExport(exports, pat.left);
-	else if (type === "RestElement") this.checkPatternExport(exports, pat.argument);
+	else if (type === "Property") this.checkPatternExport(exports$1, pat.value);
+	else if (type === "AssignmentPattern") this.checkPatternExport(exports$1, pat.left);
+	else if (type === "RestElement") this.checkPatternExport(exports$1, pat.argument);
 };
-pp$8.checkVariableExport = function(exports, decls) {
-	if (!exports) return;
+pp$8.checkVariableExport = function(exports$1, decls) {
+	if (!exports$1) return;
 	for (var i$1 = 0, list$1 = decls; i$1 < list$1.length; i$1 += 1) {
 		var decl = list$1[i$1];
-		this.checkPatternExport(exports, decl.id);
+		this.checkPatternExport(exports$1, decl.id);
 	}
 };
 pp$8.shouldParseExportStatement = function() {
 	return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction();
 };
-pp$8.parseExportSpecifier = function(exports) {
+pp$8.parseExportSpecifier = function(exports$1) {
 	var node = this.startNode();
 	node.local = this.parseModuleExportName();
 	node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local;
-	this.checkExport(exports, node.exported, node.exported.start);
+	this.checkExport(exports$1, node.exported, node.exported.start);
 	return this.finishNode(node, "ExportSpecifier");
 };
-pp$8.parseExportSpecifiers = function(exports) {
+pp$8.parseExportSpecifiers = function(exports$1) {
 	var nodes = [], first = true;
 	this.expect(types$1$1.braceL);
 	while (!this.eat(types$1$1.braceR)) {
@@ -2536,7 +3991,7 @@ pp$8.parseExportSpecifiers = function(exports) {
 			this.expect(types$1$1.comma);
 			if (this.afterTrailingComma(types$1$1.braceR)) break;
 		} else first = false;
-		nodes.push(this.parseExportSpecifier(exports));
+		nodes.push(this.parseExportSpecifier(exports$1));
 	}
 	return nodes;
 };
@@ -5351,10 +6806,10 @@ pp.readWord = function() {
 	if (this.keywords.test(word)) type = keywords[word];
 	return this.finishToken(type, word);
 };
-var version = "8.14.0";
+var version$1 = "8.14.0";
 Parser.acorn = {
 	Parser,
-	version,
+	version: version$1,
 	defaultOptions,
 	Position,
 	SourceLocation,
@@ -5386,15 +6841,15 @@ function hasTrailingSlash(input = "", respectQueryAndFragment) {
 function withTrailingSlash$1(input = "", respectQueryAndFragment) {
 	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
 	if (hasTrailingSlash(input, true)) return input || "/";
-	let path$2 = input;
+	let path$1 = input;
 	let fragment = "";
 	const fragmentIndex = input.indexOf("#");
 	if (fragmentIndex >= 0) {
-		path$2 = input.slice(0, fragmentIndex);
+		path$1 = input.slice(0, fragmentIndex);
 		fragment = input.slice(fragmentIndex);
-		if (!path$2) return fragment;
+		if (!path$1) return fragment;
 	}
-	const [s0, ...s] = path$2.split("?");
+	const [s0, ...s] = path$1.split("?");
 	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -5420,8 +6875,8 @@ const isAbsolute = function(p) {
 //#endregion
 //#region ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 const BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path$2) {
-	return path$2.replace(/\\/g, "/");
+function normalizeSlash(path$1) {
+	return path$1.replace(/\\/g, "/");
 }
 /**
 * @typedef ErrnoExceptionFields
@@ -5541,8 +6996,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
 	* @param {string} [base]
 	* @param {string} [message]
 	*/
-	(path$2, base, message) => {
-		return `Invalid package config ${path$2}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+	(path$1, base, message) => {
+		return `Invalid package config ${path$1}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
 	},
 	Error
 );
@@ -5572,8 +7027,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
 	* @param {string} base
 	* @param {boolean} [exactUrl]
 	*/
-	(path$2, base, exactUrl = false) => {
-		return `Cannot find ${exactUrl ? "module" : "package"} '${path$2}' imported from ${base}`;
+	(path$1, base, exactUrl = false) => {
+		return `Cannot find ${exactUrl ? "module" : "package"} '${path$1}' imported from ${base}`;
 	},
 	Error
 );
@@ -5611,8 +7066,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
 	* @param {string} extension
 	* @param {string} path
 	*/
-	(extension, path$2) => {
-		return `Unknown file extension "${extension}" for ${path$2}`;
+	(extension, path$1) => {
+		return `Unknown file extension "${extension}" for ${path$1}`;
 	},
 	TypeError
 );
@@ -5981,9 +7436,9 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
 * @param {string} path
 * @returns {Stats | undefined}
 */
-function tryStatSync(path$2) {
+function tryStatSync(path$1) {
 	try {
-		return statSync(path$2);
+		return statSync(path$1);
 	} catch {}
 }
 /**
@@ -6254,10 +7709,10 @@ function resolvePackageTarget(packageJsonUrl, target$1, subpath, packageSubpath,
 * @param {URL} base
 * @returns {boolean}
 */
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-	if (typeof exports === "string" || Array.isArray(exports)) return true;
-	if (typeof exports !== "object" || exports === null) return false;
-	const keys = Object.getOwnPropertyNames(exports);
+function isConditionalExportsMainSugar(exports$1, packageJsonUrl, base) {
+	if (typeof exports$1 === "string" || Array.isArray(exports$1)) return true;
+	if (typeof exports$1 !== "object" || exports$1 === null) return false;
+	const keys = Object.getOwnPropertyNames(exports$1);
 	let isConditionalSugar = false;
 	let i$1 = 0;
 	let keyIndex = -1;
@@ -6290,17 +7745,17 @@ function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
 * @returns {URL}
 */
 function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-	let exports = packageConfig.exports;
-	if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) exports = { ".": exports };
-	if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-		const target$1 = exports[packageSubpath];
+	let exports$1 = packageConfig.exports;
+	if (isConditionalExportsMainSugar(exports$1, packageJsonUrl, base)) exports$1 = { ".": exports$1 };
+	if (own.call(exports$1, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+		const target$1 = exports$1[packageSubpath];
 		const resolveResult = resolvePackageTarget(packageJsonUrl, target$1, "", packageSubpath, base, false, false, false, conditions);
 		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 		return resolveResult;
 	}
 	let bestMatch = "";
 	let bestMatchSubpath = "";
-	const keys = Object.getOwnPropertyNames(exports);
+	const keys = Object.getOwnPropertyNames(exports$1);
 	let i$1 = -1;
 	while (++i$1 < keys.length) {
 		const key = keys[i$1];
@@ -6315,7 +7770,7 @@ function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, ba
 		}
 	}
 	if (bestMatch) {
-		const target$1 = exports[bestMatch];
+		const target$1 = exports$1[bestMatch];
 		const resolveResult = resolvePackageTarget(packageJsonUrl, target$1, bestMatchSubpath, bestMatch, base, true, false, packageSubpath.endsWith("/"), conditions);
 		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 		return resolveResult;
@@ -6714,8 +8169,8 @@ function hasNodeJsAls(workerConfig) {
 */
 const nodeJsBuiltins = new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
 const NODEJS_MODULES_RE = /* @__PURE__ */ new RegExp(`^(node:)?(${builtinModules.join("|")})$`);
-function isNodeAlsModule(path$2) {
-	return /^(node:)?async_hooks$/.test(path$2);
+function isNodeAlsModule(modulePath) {
+	return /^(?:node:)?async_hooks$/.test(modulePath);
 }
 function assertHasNodeJsCompat(nodeJsCompat) {
 	assert(nodeJsCompat, `expected nodeJsCompat to be defined`);
@@ -6746,7 +8201,7 @@ var NodeJsCompatWarnings = class {
 `;
 			this.sources.forEach((importers, source) => {
 				importers.forEach((importer) => {
-					message += ` - "${source}" imported from "${path$1.relative(this.resolvedViteConfig.root, importer)}"\n`;
+					message += ` - "${source}" imported from "${nodePath.relative(this.resolvedViteConfig.root, importer)}"\n`;
 				});
 			});
 			this.resolvedViteConfig.logger.warn(message, { timestamp: true });
@@ -6804,7 +8259,7 @@ function readWorkerConfig(configPath, env) {
 		replacedByVite: /* @__PURE__ */ new Set(),
 		notRelevant: /* @__PURE__ */ new Set()
 	};
-	const config = unstable_readConfig({
+	const config = wrangler.unstable_readConfig({
 		config: configPath,
 		env
 	}, { preserveOriginalMain: true });
@@ -6831,7 +8286,7 @@ function getWarningForWorkersConfigs(configs) {
 	if (!("auxiliaryWorkers" in configs) || configs.auxiliaryWorkers.length === 0) {
 		const nonApplicableLines = getWorkerNonApplicableWarnLines(configs.entryWorker, `  - `);
 		if (nonApplicableLines.length === 0) return;
-		const lines$1 = [`\n\n\x1b[43mWARNING\x1b[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path$1.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`];
+		const lines$1 = [`\n\n\x1b[43mWARNING\x1b[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${nodePath.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`];
 		nonApplicableLines.forEach((line) => lines$1.push(line));
 		lines$1.push("");
 		return lines$1.join("\n");
@@ -6840,7 +8295,7 @@ function getWarningForWorkersConfigs(configs) {
 	const processWorkerConfig = (workerConfig, isEntryWorker = false) => {
 		const nonApplicableLines = getWorkerNonApplicableWarnLines(workerConfig, `    - `);
 		if (nonApplicableLines.length > 0) {
-			lines.push(`  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path$1.relative("", workerConfig.config.configPath)}\`)` : ""}`);
+			lines.push(`  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${nodePath.relative("", workerConfig.config.configPath)}\`)` : ""}`);
 			nonApplicableLines.forEach((line) => lines.push(line));
 		}
 	};
@@ -6933,9 +8388,9 @@ const ENTRY_MODULE_EXTENSIONS = [
 */
 function maybeResolveMain(main, configPath, root) {
 	if (!ENTRY_MODULE_EXTENSIONS.some((extension) => main.endsWith(extension))) return main;
-	const baseDir = configPath ? path$1.dirname(configPath) : root;
+	const baseDir = configPath ? nodePath.dirname(configPath) : root;
 	if (!baseDir) return main;
-	const resolvedMain = path$1.resolve(baseDir, main);
+	const resolvedMain = nodePath.resolve(baseDir, main);
 	if (!fs$1.existsSync(resolvedMain)) throw new Error(`The provided Wrangler config main field (${resolvedMain}) doesn't point to an existing file`);
 	return resolvedMain;
 }
@@ -6950,9 +8405,9 @@ function maybeResolveMain(main, configPath, root) {
 */
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
 	if (requestedConfigPath) {
-		const configPath = path$1.resolve(root, requestedConfigPath);
+		const configPath = nodePath.resolve(root, requestedConfigPath);
 		const errorMessagePrefix = `The provided configPath (${configPath})${isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : ""}`;
-		const fileExtension = path$1.extname(configPath).slice(1);
+		const fileExtension = nodePath.extname(configPath).slice(1);
 		if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
 			const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
 			throw new Error(`${errorMessagePrefix} doesn't point to a file with the correct file extension. It should point to a jsonc, json or toml file (${foundExtensionMessage} instead)`);
@@ -6967,7 +8422,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
 	for (const extension of allowedWranglerConfigExtensions) {
-		const configPath = path$1.join(root, `wrangler.${extension}`);
+		const configPath = nodePath.join(root, `wrangler.${extension}`);
 		if (fs$1.existsSync(configPath)) return configPath;
 	}
 }
@@ -6993,7 +8448,7 @@ function resolveWorkerConfig({ configPath, env, config, visitedConfigPaths, isEn
 	let nonApplicable;
 	if (configPath) ({raw, config: workerConfig, nonApplicable} = readWorkerConfigFromFile(configPath, env, { visitedConfigPaths }));
 	else {
-		workerConfig = { ...unstable_defaultWranglerConfig };
+		workerConfig = { ...wrangler.unstable_defaultWranglerConfig };
 		raw = structuredClone(workerConfig);
 		nonApplicable = {
 			replacedByVite: /* @__PURE__ */ new Set(),
@@ -7001,8 +8456,8 @@ function resolveWorkerConfig({ configPath, env, config, visitedConfigPaths, isEn
 		};
 	}
 	workerConfig = customizeWorkerConfig(workerConfig, config);
-	workerConfig.compatibility_date ??= unstable_getDevCompatibilityDate(void 0);
-	if (isEntryWorker) workerConfig.name ??= unstable_getWorkerNameFromProject(root);
+	workerConfig.compatibility_date ??= wrangler.unstable_getDevCompatibilityDate(void 0);
+	if (isEntryWorker) workerConfig.name ??= wrangler.unstable_getWorkerNameFromProject(root);
 	workerConfig.topLevelName ??= workerConfig.name;
 	return resolveWorkerType(workerConfig, raw, nonApplicable, {
 		isEntryWorker,
@@ -7017,7 +8472,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		inspectorPort: pluginConfig.inspectorPort,
 		experimental: pluginConfig.experimental ?? {}
 	};
-	const root = userConfig.root ? path$1.resolve(userConfig.root) : process.cwd();
+	const root = userConfig.root ? nodePath.resolve(userConfig.root) : process.cwd();
 	const prefixedEnv = vite.loadEnv(viteEnv.mode, root, ["CLOUDFLARE_", "WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_"]);
 	Object.assign(process.env, prefixedEnv);
 	if (viteEnv.isPreview) return {
@@ -8046,10 +9501,10 @@ var MagicString = class MagicString {
 			});
 			else return replacement(...match, match.index, str, match.groups);
 		}
-		function matchAll(re, str) {
+		function matchAll(re$5, str) {
 			let match;
 			const matches = [];
-			while (match = re.exec(str)) matches.push(match);
+			while (match = re$5.exec(str)) matches.push(match);
 			return matches;
 		}
 		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
@@ -8129,17 +9584,17 @@ const additionalModulesPlugin = createPlugin("additional-modules", (ctx) => {
 				let source;
 				try {
 					source = await fsp.readFile(modulePath);
-				} catch (error) {
+				} catch {
 					throw new Error(`Import "${modulePath}" not found. Does the file exist?`);
 				}
 				const referenceId = this.emitFile({
 					type: "asset",
-					name: path$1.basename(modulePath),
+					name: nodePath.basename(modulePath),
 					originalFileName: modulePath,
 					source
 				});
 				const emittedFileName = this.getFileName(referenceId);
-				const relativePath = vite.normalizePath(path$1.relative(path$1.dirname(chunk.fileName), emittedFileName));
+				const relativePath = vite.normalizePath(nodePath.relative(nodePath.dirname(chunk.fileName), emittedFileName));
 				const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 				magicString.update(match.index, match.index + full.length, importPath);
 			}
@@ -8250,9 +9705,9 @@ function constructHeaders({ headers, headersFile, logger }) {
 
 //#endregion
 //#region ../workers-shared/utils/configuration/validateURL.ts
-const extractPathname = (path$2 = "/", includeSearch, includeHash) => {
-	if (!path$2.startsWith("/")) path$2 = `/${path$2}`;
-	const url = new URL(`//${path$2}`, "relative://");
+const extractPathname = (path$1 = "/", includeSearch, includeHash) => {
+	if (!path$1.startsWith("/")) path$1 = `/${path$1}`;
+	const url = new URL(`//${path$1}`, "relative://");
 	return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 const URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -8309,7 +9764,7 @@ function parseHeaders(input, { maxRules = MAX_HEADER_RULES, maxLineLength = MAX_
 				lineNumber: i$1 + 1,
 				message: "No headers specified"
 			});
-			const [path$2, pathError] = validateUrl(line, false, true);
+			const [path$1, pathError] = validateUrl(line, false, true);
 			if (pathError) {
 				invalid.push({
 					line,
@@ -8320,7 +9775,7 @@ function parseHeaders(input, { maxRules = MAX_HEADER_RULES, maxLineLength = MAX_
 				continue;
 			}
 			rule = {
-				path: path$2,
+				path: path$1,
 				line,
 				headers: {},
 				unsetHeaders: []
@@ -8608,13 +10063,13 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 	const throwError = (message, Ctor) => {
 		throw new Ctor(message);
 	};
-	const checkPath = (path$2, originalPath, doThrow) => {
-		if (!isString$1(path$2)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
-		if (!path$2) return doThrow(`path must not be empty`, TypeError);
-		if (checkPath.isNotRelative(path$2)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
+	const checkPath = (path$1, originalPath, doThrow) => {
+		if (!isString$1(path$1)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+		if (!path$1) return doThrow(`path must not be empty`, TypeError);
+		if (checkPath.isNotRelative(path$1)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
 		return true;
 	};
-	const isNotRelative = (path$2) => REGEX_TEST_INVALID_PATH.test(path$2);
+	const isNotRelative = (path$1) => REGEX_TEST_INVALID_PATH.test(path$1);
 	checkPath.isNotRelative = isNotRelative;
 	checkPath.convert = (p) => p;
 	var Ignore = class {
@@ -8650,13 +10105,13 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 		addPattern(pattern) {
 			return this.add(pattern);
 		}
-		_testOne(path$2, checkUnignored) {
+		_testOne(path$1, checkUnignored) {
 			let ignored = false;
 			let unignored = false;
 			this._rules.forEach((rule) => {
 				const { negative } = rule;
 				if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) return;
-				if (rule.regex.test(path$2)) {
+				if (rule.regex.test(path$1)) {
 					ignored = !negative;
 					unignored = negative;
 				}
@@ -8666,34 +10121,34 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 				unignored
 			};
 		}
-		_test(originalPath, cache$1, checkUnignored, slices) {
-			const path$2 = originalPath && checkPath.convert(originalPath);
-			checkPath(path$2, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-			return this._t(path$2, cache$1, checkUnignored, slices);
+		_test(originalPath, cache$2, checkUnignored, slices) {
+			const path$1 = originalPath && checkPath.convert(originalPath);
+			checkPath(path$1, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+			return this._t(path$1, cache$2, checkUnignored, slices);
 		}
-		_t(path$2, cache$1, checkUnignored, slices) {
-			if (path$2 in cache$1) return cache$1[path$2];
-			if (!slices) slices = path$2.split(SLASH);
+		_t(path$1, cache$2, checkUnignored, slices) {
+			if (path$1 in cache$2) return cache$2[path$1];
+			if (!slices) slices = path$1.split(SLASH);
 			slices.pop();
-			if (!slices.length) return cache$1[path$2] = this._testOne(path$2, checkUnignored);
-			const parent = this._t(slices.join(SLASH) + SLASH, cache$1, checkUnignored, slices);
-			return cache$1[path$2] = parent.ignored ? parent : this._testOne(path$2, checkUnignored);
+			if (!slices.length) return cache$2[path$1] = this._testOne(path$1, checkUnignored);
+			const parent = this._t(slices.join(SLASH) + SLASH, cache$2, checkUnignored, slices);
+			return cache$2[path$1] = parent.ignored ? parent : this._testOne(path$1, checkUnignored);
 		}
-		ignores(path$2) {
-			return this._test(path$2, this._ignoreCache, false).ignored;
+		ignores(path$1) {
+			return this._test(path$1, this._ignoreCache, false).ignored;
 		}
 		createFilter() {
-			return (path$2) => !this.ignores(path$2);
+			return (path$1) => !this.ignores(path$1);
 		}
 		filter(paths) {
 			return makeArray(paths).filter(this.createFilter());
 		}
-		test(path$2) {
-			return this._test(path$2, this._testCache, true);
+		test(path$1) {
+			return this._test(path$1, this._testCache, true);
 		}
 	};
 	const factory = (options) => new Ignore(options);
-	const isPathValid = (path$2) => checkPath(path$2 && checkPath.convert(path$2), path$2, RETURN_FALSE);
+	const isPathValid = (path$1) => checkPath(path$1 && checkPath.convert(path$1), path$1, RETURN_FALSE);
 	factory.isPathValid = isPathValid;
 	factory.default = factory;
 	module.exports = factory;
@@ -8702,7 +10157,7 @@ var require_ignore = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/igno
 		const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
 		checkPath.convert = makePosix;
 		const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-		checkPath.isNotRelative = (path$2) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path$2) || isNotRelative(path$2);
+		checkPath.isNotRelative = (path$1) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path$1) || isNotRelative(path$1);
 	}
 }) });
 
@@ -10057,11 +11512,11 @@ var Mime = class {
 		}
 		return this;
 	}
-	getType(path$2) {
-		if (typeof path$2 !== "string") return null;
-		const last = path$2.replace(/^.*[/\\]/s, "").toLowerCase();
+	getType(path$1) {
+		if (typeof path$1 !== "string") return null;
+		const last = path$1.replace(/^.*[/\\]/s, "").toLowerCase();
 		const ext = last.replace(/^.*\./s, "").toLowerCase();
-		const hasPath = last.length < path$2.length;
+		const hasPath = last.length < path$1.length;
 		if (!(ext.length < last.length - 1) && hasPath) return null;
 		return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
 	}
@@ -10383,8 +11838,8 @@ function getErrorMap() {
 	return overrideErrorMap;
 }
 const makeIssue = (params) => {
-	const { data: data$1, path: path$2, errorMaps, issueData } = params;
-	const fullPath = [...path$2, ...issueData.path || []];
+	const { data: data$1, path: path$1, errorMaps, issueData } = params;
+	const fullPath = [...path$1, ...issueData.path || []];
 	const fullIssue = {
 		...issueData,
 		path: fullPath
@@ -10481,11 +11936,11 @@ var errorUtil;
 	errorUtil$1.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-	constructor(parent, value, path$2, key) {
+	constructor(parent, value, path$1, key) {
 		this._cachedPath = [];
 		this.parent = parent;
 		this.data = value;
-		this._path = path$2;
+		this._path = path$1;
 		this._key = key;
 	}
 	get path() {
@@ -10785,9 +12240,9 @@ const datetimeRegex = (args) => {
 	else if (args.offset) return /* @__PURE__ */ new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
 	else return /* @__PURE__ */ new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
 };
-function isValidIP(ip, version$1) {
-	if ((version$1 === "v4" || !version$1) && ipv4Regex.test(ip)) return true;
-	if ((version$1 === "v6" || !version$1) && ipv6Regex.test(ip)) return true;
+function isValidIP(ip, version$2) {
+	if ((version$2 === "v4" || !version$2) && ipv4Regex.test(ip)) return true;
+	if ((version$2 === "v6" || !version$2) && ipv6Regex.test(ip)) return true;
 	return false;
 }
 var ZodString = class ZodString extends ZodType {
@@ -13647,10 +15102,10 @@ function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig
 	};
 }
 function getRedirectsConfigPath(config) {
-	return path$1.join(config.publicDir, REDIRECTS_FILENAME);
+	return nodePath.join(config.publicDir, REDIRECTS_FILENAME);
 }
 function getHeadersConfigPath(config) {
-	return path$1.join(config.publicDir, HEADERS_FILENAME);
+	return nodePath.join(config.publicDir, HEADERS_FILENAME);
 }
 
 //#endregion
@@ -13769,7 +15224,7 @@ function createBuildApp(resolvedPluginConfig) {
 	return async (builder) => {
 		const clientEnvironment = builder.environments.client;
 		assert(clientEnvironment, `No "client" environment`);
-		const defaultHtmlPath = path$1.resolve(builder.config.root, "index.html");
+		const defaultHtmlPath = nodePath.resolve(builder.config.root, "index.html");
 		const hasClientEntry = clientEnvironment.config.build.rollupOptions.input || fs$1.existsSync(defaultHtmlPath);
 		if (resolvedPluginConfig.type === "assets-only") {
 			if (hasClientEntry) await builder.build(clientEnvironment);
@@ -13785,39 +15240,39 @@ function createBuildApp(resolvedPluginConfig) {
 		const { entryWorkerEnvironmentName } = resolvedPluginConfig;
 		const entryWorkerEnvironment = builder.environments[entryWorkerEnvironmentName];
 		assert(entryWorkerEnvironment, `No "${entryWorkerEnvironmentName}" environment`);
-		const entryWorkerBuildDirectory = path$1.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir);
+		const entryWorkerBuildDirectory = nodePath.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir);
 		const importedAssetPaths = getImportedAssetPaths(loadViteManifest(entryWorkerBuildDirectory));
 		if (hasClientEntry) await builder.build(clientEnvironment);
 		else if (importedAssetPaths.size || getHasPublicAssets(builder.config)) await fallbackBuild(builder, clientEnvironment);
 		else {
-			const entryWorkerConfigPath = path$1.join(entryWorkerBuildDirectory, "wrangler.json");
+			const entryWorkerConfigPath = nodePath.join(entryWorkerBuildDirectory, "wrangler.json");
 			const workerConfig = JSON.parse(fs$1.readFileSync(entryWorkerConfigPath, "utf-8"));
 			workerConfig.assets = void 0;
 			fs$1.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
 			return;
 		}
-		const clientBuildDirectory = path$1.resolve(builder.config.root, clientEnvironment.config.build.outDir);
+		const clientBuildDirectory = nodePath.resolve(builder.config.root, clientEnvironment.config.build.outDir);
 		const movedAssetPaths = [];
 		for (const assetPath of importedAssetPaths) {
-			const src = path$1.join(entryWorkerBuildDirectory, assetPath);
-			const dest = path$1.join(clientBuildDirectory, assetPath);
-			if (!fs$1.existsSync(src)) continue;
-			if (fs$1.existsSync(dest)) fs$1.unlinkSync(src);
+			const src$1 = nodePath.join(entryWorkerBuildDirectory, assetPath);
+			const dest = nodePath.join(clientBuildDirectory, assetPath);
+			if (!fs$1.existsSync(src$1)) continue;
+			if (fs$1.existsSync(dest)) fs$1.unlinkSync(src$1);
 			else {
-				const destDir = path$1.dirname(dest);
+				const destDir = nodePath.dirname(dest);
 				fs$1.mkdirSync(destDir, { recursive: true });
-				fs$1.renameSync(src, dest);
+				fs$1.renameSync(src$1, dest);
 				movedAssetPaths.push(dest);
 			}
 		}
-		if (movedAssetPaths.length) builder.config.logger.info([`${colors.green("✓")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`, ...movedAssetPaths.map((assetPath) => colors.dim(path$1.relative(builder.config.root, assetPath)))].join("\n"));
+		if (movedAssetPaths.length) builder.config.logger.info([`${colors.green("✓")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`, ...movedAssetPaths.map((assetPath) => colors.dim(nodePath.relative(builder.config.root, assetPath)))].join("\n"));
 	};
 }
 function getHasPublicAssets({ publicDir }) {
 	let hasPublicAssets = false;
 	if (publicDir) try {
 		if (fs$1.readdirSync(publicDir).length) hasPublicAssets = true;
-	} catch (error) {}
+	} catch {}
 	return hasPublicAssets;
 }
 async function fallbackBuild(builder, environment) {
@@ -13827,11 +15282,11 @@ async function fallbackBuild(builder, environment) {
 		output: { entryFileNames: CLIENT_FALLBACK_ENTRY_NAME }
 	};
 	await builder.build(environment);
-	const fallbackEntryPath = path$1.resolve(builder.config.root, environment.config.build.outDir, CLIENT_FALLBACK_ENTRY_NAME);
+	const fallbackEntryPath = nodePath.resolve(builder.config.root, environment.config.build.outDir, CLIENT_FALLBACK_ENTRY_NAME);
 	fs$1.unlinkSync(fallbackEntryPath);
 }
 function loadViteManifest(directory) {
-	const contents = fs$1.readFileSync(path$1.resolve(directory, ".vite", "manifest.json"), "utf-8");
+	const contents = fs$1.readFileSync(nodePath.resolve(directory, ".vite", "manifest.json"), "utf-8");
 	return JSON.parse(contents);
 }
 function getImportedAssetPaths(viteManifest) {
@@ -14022,7 +15477,7 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
 * Calls `unstable_getVarsForDev` with the current Cloudflare environment to get local dev variables from the `.dev.vars` and `.env` files.
 */
 function getLocalDevVarsForPreview(configPath, cloudflareEnv) {
-	const dotDevDotVars = unstable_getVarsForDev(configPath, void 0, {}, cloudflareEnv);
+	const dotDevDotVars = wrangler.unstable_getVarsForDev(configPath, void 0, {}, cloudflareEnv);
 	const dotDevDotVarsEntries = Array.from(Object.entries(dotDevDotVars));
 	if (dotDevDotVarsEntries.length > 0) return dotDevDotVarsEntries.map(([key, value]) => {
 		return `${key} = "${value?.toString().replaceAll(`"`, `\\"`)}"\n`;
@@ -14033,12 +15488,12 @@ function getLocalDevVarsForPreview(configPath, cloudflareEnv) {
 */
 function hasLocalDevVarsFileChanged({ configPaths, cloudflareEnv }, changedFilePath) {
 	return [...configPaths].some((configPath) => {
-		const configDir = path$1.dirname(configPath);
+		const configDir = nodePath.dirname(configPath);
 		return [
 			".dev.vars",
 			".env",
 			...cloudflareEnv ? [`.dev.vars.${cloudflareEnv}`, `.env.${cloudflareEnv}`] : []
-		].some((localDevFile) => changedFilePath === path$1.join(configDir, localDevFile));
+		].some((localDevFile) => changedFilePath === nodePath.join(configDir, localDevFile));
 	});
 }
 
@@ -14159,7 +15614,7 @@ function addDebugToVitePrintUrls(server) {
 		const localUrl = server.resolvedUrls?.local[0];
 		if (localUrl) {
 			const { protocol, hostname, port } = new URL(localUrl);
-			const colorDebugUrl = (url) => colors.dim(colors.yellow(url.replace(/:(\d+)\//, (_, port$1) => `:${colors.bold(port$1)}/`)));
+			const colorDebugUrl = (url) => colors.dim(colors.yellow(url.replace(/:(\d+)\//, (_, portNumber) => `:${colors.bold(portNumber)}/`)));
 			server.config.logger.info(`  ${colors.green("➜")}  ${colors.bold("Debug")}:   ${colorDebugUrl(`${protocol}//${hostname}:${port}${DEBUG_PATH}`)}`);
 		}
 	};
@@ -14608,11 +16063,11 @@ const getQueryString = (params) => {
 };
 const getUrl = (config, options) => {
 	const encoder = config.ENCODE_PATH || encodeURI;
-	const path$2 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+	const path$1 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
 		if (options.path?.hasOwnProperty(group)) return encoder(String(options.path[group]));
 		return substring;
 	});
-	const url = `${config.BASE}${path$2}`;
+	const url = `${config.BASE}${path$1}`;
 	if (options.query) return `${url}${getQueryString(options.query)}`;
 	return url;
 };
@@ -15452,7 +16907,7 @@ const INTERNAL_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
 const PUBLIC_DIR_PREFIX = "/__vite_public_dir__";
 function getPersistenceRoot(root, persistState) {
 	if (persistState === false) return;
-	return path$1.resolve(root, typeof persistState === "object" ? persistState.path : ".wrangler/state", "v3");
+	return nodePath.resolve(root, typeof persistState === "object" ? persistState.path : ".wrangler/state", "v3");
 }
 const miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
 const ROUTER_WORKER_PATH = "./workers/router-worker.js";
@@ -15473,7 +16928,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$1.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+				path: nodePath.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(ROUTER_WORKER_PATH, import.meta.url)))
 			}],
 			bindings: { CONFIG: { has_user_worker: resolvedPluginConfig.type === "workers" } },
@@ -15488,7 +16943,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$1.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+				path: nodePath.join(miniflareModulesRoot, ASSET_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(ASSET_WORKER_PATH, import.meta.url)))
 			}],
 			bindings: {
@@ -15503,11 +16958,11 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 						const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
 						const publicPath = withTrailingSlash(publicDir.slice(root.length));
 						if (publicDirInRoot && pathname.startsWith(publicPath)) return Response$1.json(null);
-						const publicDirFilePath = path$1.join(publicDir, pathname);
-						const rootDirFilePath = path$1.join(root, pathname);
+						const publicDirFilePath = nodePath.join(publicDir, pathname);
+						const rootDirFilePath = nodePath.join(root, pathname);
 						for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) try {
 							if ((await fsp.stat(resolvedPath)).isFile()) return Response$1.json(resolvedPath === publicDirFilePath ? `${PUBLIC_DIR_PREFIX}${pathname}` : pathname);
-						} catch (error) {}
+						} catch {}
 					}
 					return Response$1.json(null);
 				},
@@ -15515,12 +16970,12 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 					const { pathname } = new URL(request$1.url);
 					const { root, publicDir } = resolvedViteConfig;
 					const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
-					const resolvedPath = isInPublicDir ? path$1.join(publicDir, pathname.slice(20)) : path$1.join(root, pathname);
+					const resolvedPath = isInPublicDir ? nodePath.join(publicDir, pathname.slice(20)) : nodePath.join(root, pathname);
 					try {
 						let html = await fsp.readFile(resolvedPath, "utf-8");
 						if (!isInPublicDir) html = await viteDevServer.transformIndexHtml(resolvedPath, html);
 						return new Response$1(html, { headers: { "Content-Type": "text/html" } });
-					} catch (error) {
+					} catch {
 						throw new Error(`Unexpected error. Failed to load "${pathname}".`);
 					}
 				}
@@ -15532,7 +16987,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			modulesRoot: miniflareModulesRoot,
 			modules: [{
 				type: "ESModule",
-				path: path$1.join(miniflareModulesRoot, VITE_PROXY_WORKER_PATH),
+				path: nodePath.join(miniflareModulesRoot, VITE_PROXY_WORKER_PATH),
 				contents: fs$1.readFileSync(fileURLToPath(new URL(VITE_PROXY_WORKER_PATH, import.meta.url)))
 			}],
 			serviceBindings: {
@@ -15543,9 +16998,9 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 	];
 	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
 	const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(async ([environmentName, worker]) => {
-		const bindings = unstable_convertConfigBindingsToStartWorkerBindings(worker.config);
+		const bindings = wrangler.unstable_convertConfigBindingsToStartWorkerBindings(worker.config);
 		const preExistingRemoteProxySession = worker.config.configPath ? remoteProxySessionsDataMap.get(worker.config.configPath) : void 0;
-		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await maybeStartOrUpdateRemoteProxySession({
+		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await wrangler.maybeStartOrUpdateRemoteProxySession({
 			name: worker.config.name,
 			bindings: bindings ?? {},
 			account_id: worker.config.account_id
@@ -15563,7 +17018,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			});
 			for (const option of options ?? []) containerTagToOptionsMap.set(option.image_tag, option);
 		}
-		const { externalWorkers: externalWorkers$1, workerOptions } = unstable_getMiniflareWorkerOptions({
+		const { externalWorkers: externalWorkers$1, workerOptions } = wrangler.unstable_getMiniflareWorkerOptions({
 			...worker.config,
 			assets: void 0
 		}, resolvedPluginConfig.cloudflareEnv, {
@@ -15586,11 +17041,11 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 				modulesRoot: miniflareModulesRoot,
 				modules: [{
 					type: "ESModule",
-					path: path$1.join(miniflareModulesRoot, WRAPPER_PATH),
+					path: nodePath.join(miniflareModulesRoot, WRAPPER_PATH),
 					contents: wrappers.join("\n")
 				}, {
 					type: "ESModule",
-					path: path$1.join(miniflareModulesRoot, RUNNER_PATH),
+					path: nodePath.join(miniflareModulesRoot, RUNNER_PATH),
 					contents: fs$1.readFileSync(fileURLToPath(new URL(RUNNER_PATH, import.meta.url)))
 				}],
 				unsafeUseModuleFallbackService: true,
@@ -15654,7 +17109,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 				let contents;
 				try {
 					contents = await fsp.readFile(modulePath);
-				} catch (error) {
+				} catch {
 					throw new Error(`Import "${modulePath}" not found. Does the file exist?`);
 				}
 				switch (moduleType) {
@@ -15670,8 +17125,8 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 }
 function getPreviewModules(main, modulesRules) {
 	assert(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-	const rootPath = path$1.dirname(main);
-	const entryPath = path$1.basename(main);
+	const rootPath = nodePath.dirname(main);
+	const entryPath = nodePath.basename(main);
 	return {
 		rootPath,
 		modules: [{
@@ -15680,9 +17135,9 @@ function getPreviewModules(main, modulesRules) {
 		}, ...modulesRules.flatMap(({ type, include }) => globSync(include, {
 			cwd: rootPath,
 			ignore: entryPath
-		}).map((path$2) => ({
+		}).map((globPath) => ({
 			type,
-			path: path$2
+			path: globPath
 		})))]
 	};
 }
@@ -15691,9 +17146,9 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 	const { resolvedPluginConfig, resolvedViteConfig } = ctx;
 	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
 	const workers = (await Promise.all(resolvedPluginConfig.workers.map(async (workerConfig, i$1) => {
-		const bindings = unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
+		const bindings = wrangler.unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
 		const preExistingRemoteProxySessionData = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
-		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await maybeStartOrUpdateRemoteProxySession({
+		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await wrangler.maybeStartOrUpdateRemoteProxySession({
 			name: workerConfig.name,
 			bindings: bindings ?? {},
 			account_id: workerConfig.account_id
@@ -15711,7 +17166,7 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 			});
 			for (const option of options ?? []) containerTagToOptionsMap.set(option.image_tag, option);
 		}
-		const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(workerConfig, void 0, {
+		const miniflareWorkerOptions = wrangler.unstable_getMiniflareWorkerOptions(workerConfig, void 0, {
 			remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
 			containerBuildId
 		});
@@ -16009,11 +17464,11 @@ const nodeJsCompatWarningsPlugin = createPlugin("nodejs-compat-warnings", (ctx)
 			if (workerConfig && !nodeJsCompat) return { optimizeDeps: { esbuildOptions: { plugins: [{
 				name: "vite-plugin-cloudflare:nodejs-compat-warnings-resolver",
 				setup(build) {
-					build.onResolve({ filter: NODEJS_MODULES_RE }, ({ path: path$2, importer }) => {
-						if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path$2)) return;
-						nodeJsCompatWarningsMap.get(workerConfig)?.registerImport(path$2, importer);
+					build.onResolve({ filter: NODEJS_MODULES_RE }, ({ path: path$1, importer }) => {
+						if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path$1)) return;
+						nodeJsCompatWarningsMap.get(workerConfig)?.registerImport(path$1, importer);
 						return {
-							path: path$2,
+							path: path$1,
 							external: true
 						};
 					});
@@ -16114,7 +17569,7 @@ const outputConfigPlugin = createPlugin("output-config", (ctx) => {
 function getAssetsDirectory(workerOutputDirectory, resolvedViteConfig) {
 	const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
 	assert(clientOutputDirectory, "Unexpected error: client output directory is undefined");
-	return path$1.relative(path$1.resolve(resolvedViteConfig.root, workerOutputDirectory), path$1.resolve(resolvedViteConfig.root, clientOutputDirectory));
+	return nodePath.relative(nodePath.resolve(resolvedViteConfig.root, workerOutputDirectory), nodePath.resolve(resolvedViteConfig.root, clientOutputDirectory));
 }
 
 //#endregion
@@ -16159,6 +17614,64 @@ const previewPlugin = createPlugin("preview", (ctx) => {
 	} };
 });
 
+//#endregion
+//#region src/plugins/shortcuts.ts
+const shortcutsPlugin = createPlugin("shortcuts", (ctx) => {
+	const isCustomShortcutsSupported = satisfiesViteVersion("7.2.7");
+	return {
+		async configureServer(viteDevServer) {
+			if (!isCustomShortcutsSupported) return;
+			assertIsNotPreview(ctx);
+			addBindingsShortcut(viteDevServer, ctx);
+		},
+		async configurePreviewServer(vitePreviewServer) {
+			if (!isCustomShortcutsSupported) return;
+			assertIsPreview(ctx);
+			addBindingsShortcut(vitePreviewServer, ctx);
+		}
+	};
+});
+function addBindingsShortcut(server, ctx) {
+	const workerConfigs = ctx.allWorkerConfigs;
+	if (workerConfigs.length === 0) return;
+	const registryPath = getDefaultDevRegistryPath();
+	const printBindingsShortcut = {
+		key: "b",
+		description: "list configured Cloudflare bindings",
+		action: (viteServer) => {
+			viteServer.config.logger.info("");
+			for (const workerConfig of workerConfigs) wrangler.unstable_printBindings({
+				...workerConfig,
+				assets: workerConfig.assets?.binding ? {
+					...workerConfig.assets,
+					binding: workerConfig.assets.binding
+				} : void 0,
+				unsafe: {
+					bindings: workerConfig.unsafe.bindings,
+					metadata: workerConfig.unsafe.metadata,
+					capnp: workerConfig.unsafe.capnp
+				},
+				queues: workerConfig.queues.producers?.map((queue) => ({
+					...queue,
+					queue_name: queue.queue
+				}))
+			}, workerConfig.tail_consumers, workerConfig.streaming_tail_consumers, workerConfig.containers, {
+				warnIfNoBindings: true,
+				isMultiWorker: workerConfigs.length > 1,
+				name: workerConfig.name ?? "Your Worker",
+				registry: getWorkerRegistry(registryPath),
+				log: (message) => viteServer.config.logger.info(message)
+			});
+		}
+	};
+	const bindCLIShortcuts = server.bindCLIShortcuts.bind(server);
+	server.bindCLIShortcuts = (options) => {
+		if (server.httpServer && process.stdin.isTTY && !process.env.CI && options?.print) server.config.logger.info(colors.dim(colors.green("  ➜")) + colors.dim("  press ") + colors.bold(`${printBindingsShortcut.key} + enter`) + colors.dim(` to ${printBindingsShortcut.description}`));
+		bindCLIShortcuts(options);
+	};
+	server.bindCLIShortcuts({ customShortcuts: [printBindingsShortcut] });
+}
+
 //#endregion
 //#region src/plugins/trigger-handlers.ts
 /**
@@ -16209,6 +17722,7 @@ const sharedContext = {
 	hasShownWorkerConfigWarnings: false,
 	isRestartingDevServer: false
 };
+await assertWranglerVersion();
 /**
 * Vite plugin that enables a full-featured integration between Vite and the Cloudflare Workers runtime.
 *
@@ -16242,6 +17756,7 @@ function cloudflare(pluginConfig = {}) {
 		configPlugin(ctx),
 		devPlugin(ctx),
 		previewPlugin(ctx),
+		shortcutsPlugin(ctx),
 		debugPlugin(ctx),
 		triggerHandlersPlugin(ctx),
 		virtualModulesPlugin(ctx),