@cloudflare/config 0.0.0

package/dist/index.mjs

@@ -0,0 +1,3699 @@
+import { a as bindings, i as triggers, n as resolveWorkerDefinition, r as exports$1, t as defineWorker } from "./public-CFHebTo4.mjs";
+import * as nodeModule from "node:module";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import path2, { dirname, isAbsolute, join, resolve } from "node:path";
+import fs2, { existsSync, readFileSync, statSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as z from "zod";
+
+//#region rolldown:runtime
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+//#endregion
+//#region ../workers-utils/dist/chunk-6IEM75FG.mjs
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+
+//#endregion
+//#region ../workers-utils/dist/chunk-DPLELERC.mjs
+function isDirectory(path$1) {
+	return fs2.statSync(path$1, { throwIfNoEntry: false })?.isDirectory() ?? false;
+}
+__name(isDirectory, "isDirectory");
+function removeDir(dirPath, { fireAndForget = false } = {}) {
+	const result = fs2.promises.rm(dirPath, {
+		recursive: true,
+		force: true,
+		maxRetries: 5,
+		retryDelay: 100
+	});
+	if (fireAndForget) result.catch(() => {});
+	else return result;
+}
+__name(removeDir, "removeDir");
+function removeDirSync(dirPath) {
+	fs2.rmSync(dirPath, {
+		recursive: true,
+		force: true,
+		maxRetries: 5,
+		retryDelay: 100
+	});
+}
+__name(removeDirSync, "removeDirSync");
+
+//#endregion
+//#region ../workers-utils/dist/chunk-WYII773A.mjs
+function partitionExports(exports$2) {
+	const partitioned = {
+		"durable-object": {},
+		worker: {}
+	};
+	if (exports$2 === void 0) return partitioned;
+	for (const [name, entry] of Object.entries(exports$2)) partitioned[entry.type][name] = entry;
+	return partitioned;
+}
+__name(partitionExports, "partitionExports");
+var UserError = class extends Error {
+	static {
+		__name(this, "UserError");
+	}
+	telemetryMessage;
+	constructor(message, options) {
+		super(message, options);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.telemetryMessage = typeof options?.telemetryMessage === "string" ? options.telemetryMessage : options?.telemetryMessage ? message : void 0;
+	}
+};
+var DeprecationError = class extends UserError {
+	static {
+		__name(this, "DeprecationError");
+	}
+	constructor(message, options) {
+		super(`Deprecation:
+${message}`, options);
+	}
+};
+var FatalError = class extends UserError {
+	static {
+		__name(this, "FatalError");
+	}
+	code;
+	constructor(message, options) {
+		super(message, options);
+		this.code = options.code;
+	}
+};
+var CommandLineArgsError = class extends UserError {
+	static {
+		__name(this, "CommandLineArgsError");
+	}
+};
+var JsonFriendlyFatalError = class extends FatalError {
+	static {
+		__name(this, "JsonFriendlyFatalError");
+	}
+};
+var MissingConfigError = class extends Error {
+	static {
+		__name(this, "MissingConfigError");
+	}
+	telemetryMessage;
+	constructor(key) {
+		super(`Missing config value for ${key}`);
+		this.telemetryMessage = `Missing config value for ${key}`;
+	}
+};
+function createFatalError(message, isJson, options) {
+	if (isJson) return new JsonFriendlyFatalError(JSON.stringify(message), options);
+	return new FatalError(`${message}`, options);
+}
+__name(createFatalError, "createFatalError");
+function createScanner(text, ignoreTrivia = false) {
+	const len = text.length;
+	let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+	function scanHexDigits(count, exact) {
+		let digits = 0;
+		let value2 = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value2 = value2 * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value2 = value2 * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value2 = value2 * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value2 = -1;
+		return value2;
+	}
+	__name(scanHexDigits, "scanHexDigits");
+	function setPosition(newPosition) {
+		pos = newPosition;
+		value = "";
+		tokenOffset = 0;
+		token = 16;
+		scanError = 0;
+	}
+	__name(setPosition, "setPosition");
+	function scanNumber() {
+		let start = pos;
+		if (text.charCodeAt(pos) === 48) pos++;
+		else {
+			pos++;
+			while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+		}
+		if (pos < text.length && text.charCodeAt(pos) === 46) {
+			pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+			} else {
+				scanError = 3;
+				return text.substring(start, pos);
+			}
+		}
+		let end = pos;
+		if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+			pos++;
+			if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++;
+			if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+				pos++;
+				while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+				end = pos;
+			} else scanError = 3;
+		}
+		return text.substring(start, end);
+	}
+	__name(scanNumber, "scanNumber");
+	function scanString() {
+		let result = "", start = pos;
+		while (true) {
+			if (pos >= len) {
+				result += text.substring(start, pos);
+				scanError = 2;
+				break;
+			}
+			const ch = text.charCodeAt(pos);
+			if (ch === 34) {
+				result += text.substring(start, pos);
+				pos++;
+				break;
+			}
+			if (ch === 92) {
+				result += text.substring(start, pos);
+				pos++;
+				if (pos >= len) {
+					scanError = 2;
+					break;
+				}
+				switch (text.charCodeAt(pos++)) {
+					case 34:
+						result += "\"";
+						break;
+					case 92:
+						result += "\\";
+						break;
+					case 47:
+						result += "/";
+						break;
+					case 98:
+						result += "\b";
+						break;
+					case 102:
+						result += "\f";
+						break;
+					case 110:
+						result += "\n";
+						break;
+					case 114:
+						result += "\r";
+						break;
+					case 116:
+						result += "	";
+						break;
+					case 117:
+						const ch3 = scanHexDigits(4, true);
+						if (ch3 >= 0) result += String.fromCharCode(ch3);
+						else scanError = 4;
+						break;
+					default: scanError = 5;
+				}
+				start = pos;
+				continue;
+			}
+			if (ch >= 0 && ch <= 31) if (isLineBreak(ch)) {
+				result += text.substring(start, pos);
+				scanError = 2;
+				break;
+			} else scanError = 6;
+			pos++;
+		}
+		return result;
+	}
+	__name(scanString, "scanString");
+	function scanNext() {
+		value = "";
+		scanError = 0;
+		tokenOffset = pos;
+		lineStartOffset = lineNumber;
+		prevTokenLineStartOffset = tokenLineStartOffset;
+		if (pos >= len) {
+			tokenOffset = len;
+			return token = 17;
+		}
+		let code = text.charCodeAt(pos);
+		if (isWhiteSpace(code)) {
+			do {
+				pos++;
+				value += String.fromCharCode(code);
+				code = text.charCodeAt(pos);
+			} while (isWhiteSpace(code));
+			return token = 15;
+		}
+		if (isLineBreak(code)) {
+			pos++;
+			value += String.fromCharCode(code);
+			if (code === 13 && text.charCodeAt(pos) === 10) {
+				pos++;
+				value += "\n";
+			}
+			lineNumber++;
+			tokenLineStartOffset = pos;
+			return token = 14;
+		}
+		switch (code) {
+			case 123:
+				pos++;
+				return token = 1;
+			case 125:
+				pos++;
+				return token = 2;
+			case 91:
+				pos++;
+				return token = 3;
+			case 93:
+				pos++;
+				return token = 4;
+			case 58:
+				pos++;
+				return token = 6;
+			case 44:
+				pos++;
+				return token = 5;
+			case 34:
+				pos++;
+				value = scanString();
+				return token = 10;
+			case 47:
+				const start = pos - 1;
+				if (text.charCodeAt(pos + 1) === 47) {
+					pos += 2;
+					while (pos < len) {
+						if (isLineBreak(text.charCodeAt(pos))) break;
+						pos++;
+					}
+					value = text.substring(start, pos);
+					return token = 12;
+				}
+				if (text.charCodeAt(pos + 1) === 42) {
+					pos += 2;
+					const safeLength = len - 1;
+					let commentClosed = false;
+					while (pos < safeLength) {
+						const ch = text.charCodeAt(pos);
+						if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+							pos += 2;
+							commentClosed = true;
+							break;
+						}
+						pos++;
+						if (isLineBreak(ch)) {
+							if (ch === 13 && text.charCodeAt(pos) === 10) pos++;
+							lineNumber++;
+							tokenLineStartOffset = pos;
+						}
+					}
+					if (!commentClosed) {
+						pos++;
+						scanError = 1;
+					}
+					value = text.substring(start, pos);
+					return token = 13;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+			case 45:
+				value += String.fromCharCode(code);
+				pos++;
+				if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+			case 48:
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57:
+				value += scanNumber();
+				return token = 11;
+			default:
+				while (pos < len && isUnknownContentCharacter(code)) {
+					pos++;
+					code = text.charCodeAt(pos);
+				}
+				if (tokenOffset !== pos) {
+					value = text.substring(tokenOffset, pos);
+					switch (value) {
+						case "true": return token = 8;
+						case "false": return token = 9;
+						case "null": return token = 7;
+					}
+					return token = 16;
+				}
+				value += String.fromCharCode(code);
+				pos++;
+				return token = 16;
+		}
+	}
+	__name(scanNext, "scanNext");
+	function isUnknownContentCharacter(code) {
+		if (isWhiteSpace(code) || isLineBreak(code)) return false;
+		switch (code) {
+			case 125:
+			case 93:
+			case 123:
+			case 91:
+			case 34:
+			case 58:
+			case 44:
+			case 47: return false;
+		}
+		return true;
+	}
+	__name(isUnknownContentCharacter, "isUnknownContentCharacter");
+	function scanNextNonTrivia() {
+		let result;
+		do
+			result = scanNext();
+		while (result >= 12 && result <= 15);
+		return result;
+	}
+	__name(scanNextNonTrivia, "scanNextNonTrivia");
+	return {
+		setPosition,
+		getPosition: /* @__PURE__ */ __name(() => pos, "getPosition"),
+		scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+		getToken: /* @__PURE__ */ __name(() => token, "getToken"),
+		getTokenValue: /* @__PURE__ */ __name(() => value, "getTokenValue"),
+		getTokenOffset: /* @__PURE__ */ __name(() => tokenOffset, "getTokenOffset"),
+		getTokenLength: /* @__PURE__ */ __name(() => pos - tokenOffset, "getTokenLength"),
+		getTokenStartLine: /* @__PURE__ */ __name(() => lineStartOffset, "getTokenStartLine"),
+		getTokenStartCharacter: /* @__PURE__ */ __name(() => tokenOffset - prevTokenLineStartOffset, "getTokenStartCharacter"),
+		getTokenError: /* @__PURE__ */ __name(() => scanError, "getTokenError")
+	};
+}
+__name(createScanner, "createScanner");
+function isWhiteSpace(ch) {
+	return ch === 32 || ch === 9;
+}
+__name(isWhiteSpace, "isWhiteSpace");
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13;
+}
+__name(isLineBreak, "isLineBreak");
+function isDigit(ch) {
+	return ch >= 48 && ch <= 57;
+}
+__name(isDigit, "isDigit");
+var CharacterCodes;
+(function(CharacterCodes2) {
+	CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+	CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+	CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+	CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+	CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+	CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+	CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+	CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+	CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+	CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+	CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+	CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+	CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+	CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+	CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+	CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+	CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+	CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+	CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+	CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+	CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+	CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+	CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+	CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+	CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+	CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+	CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+	CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+	CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+	CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+	CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+	CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+	CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+	CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+	CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+	CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+	CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+	CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+	CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+	CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+	CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+	CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+	CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+	CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+	CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+	CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+	CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+	CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+	CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+	CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+	CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+	CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+	CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+	CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+	CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+	CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+	CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+	CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+	CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+	CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+	CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+	CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+	CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+	CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+	CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+	CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+	CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+	CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+	CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+	CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+	CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+	CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+	CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+	CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+	CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+	CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+	CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+	CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+	CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+	CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+function format(documentText, range, options) {
+	let initialIndentLevel;
+	let formatText;
+	let formatTextStart;
+	let rangeStart;
+	let rangeEnd;
+	if (range) {
+		rangeStart = range.offset;
+		rangeEnd = rangeStart + range.length;
+		formatTextStart = rangeStart;
+		while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) formatTextStart--;
+		let endOffset = rangeEnd;
+		while (endOffset < documentText.length && !isEOL(documentText, endOffset)) endOffset++;
+		formatText = documentText.substring(formatTextStart, endOffset);
+		initialIndentLevel = computeIndentLevel(formatText, options);
+	} else {
+		formatText = documentText;
+		initialIndentLevel = 0;
+		formatTextStart = 0;
+		rangeStart = 0;
+		rangeEnd = documentText.length;
+	}
+	const eol = getEOL(options, documentText);
+	let numberLineBreaks = 0;
+	let indentLevel = 0;
+	let indentValue;
+	if (options.insertSpaces) indentValue = repeat(" ", options.tabSize || 4);
+	else indentValue = "	";
+	let scanner = createScanner(formatText, false);
+	let hasError = false;
+	function newLinesAndIndent() {
+		if (numberLineBreaks > 1) return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+		else return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+	}
+	__name(newLinesAndIndent, "newLinesAndIndent");
+	function scanNext() {
+		let token = scanner.scan();
+		numberLineBreaks = 0;
+		while (token === 15 || token === 14) {
+			if (token === 14 && options.keepLines) numberLineBreaks += 1;
+			else if (token === 14) numberLineBreaks = 1;
+			token = scanner.scan();
+		}
+		hasError = token === 16 || scanner.getTokenError() !== 0;
+		return token;
+	}
+	__name(scanNext, "scanNext");
+	const editOperations = [];
+	function addEdit(text, startOffset, endOffset) {
+		if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) editOperations.push({
+			offset: startOffset,
+			length: endOffset - startOffset,
+			content: text
+		});
+	}
+	__name(addEdit, "addEdit");
+	let firstToken = scanNext();
+	if (options.keepLines && numberLineBreaks > 0) addEdit(repeat(eol, numberLineBreaks), 0, 0);
+	if (firstToken !== 17) {
+		let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+		addEdit(repeat(indentValue, initialIndentLevel), formatTextStart, firstTokenStart);
+	}
+	while (firstToken !== 17) {
+		let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+		let secondToken = scanNext();
+		let replaceContent = "";
+		let needsLineBreak = false;
+		while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+			let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+			addEdit(" ", firstTokenEnd, commentTokenStart);
+			firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+			needsLineBreak = secondToken === 12;
+			replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+			secondToken = scanNext();
+		}
+		if (secondToken === 2) {
+			if (firstToken !== 1) indentLevel--;
+			if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) replaceContent = newLinesAndIndent();
+			else if (options.keepLines) replaceContent = " ";
+		} else if (secondToken === 4) {
+			if (firstToken !== 3) indentLevel--;
+			if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) replaceContent = newLinesAndIndent();
+			else if (options.keepLines) replaceContent = " ";
+		} else {
+			switch (firstToken) {
+				case 3:
+				case 1:
+					indentLevel++;
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = " ";
+					break;
+				case 5:
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = " ";
+					break;
+				case 12:
+					replaceContent = newLinesAndIndent();
+					break;
+				case 13:
+					if (numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = " ";
+					break;
+				case 6:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = " ";
+					break;
+				case 10:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (secondToken === 6 && !needsLineBreak) replaceContent = "";
+					break;
+				case 7:
+				case 8:
+				case 9:
+				case 11:
+				case 2:
+				case 4:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) replaceContent = " ";
+					else if (secondToken !== 5 && secondToken !== 17) hasError = true;
+					break;
+				case 16:
+					hasError = true;
+					break;
+			}
+			if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) replaceContent = newLinesAndIndent();
+		}
+		if (secondToken === 17) if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+		else replaceContent = options.insertFinalNewline ? eol : "";
+		const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+		addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+		firstToken = secondToken;
+	}
+	return editOperations;
+}
+__name(format, "format");
+function repeat(s, count) {
+	let result = "";
+	for (let i = 0; i < count; i++) result += s;
+	return result;
+}
+__name(repeat, "repeat");
+function computeIndentLevel(content, options) {
+	let i = 0;
+	let nChars = 0;
+	const tabSize = options.tabSize || 4;
+	while (i < content.length) {
+		let ch = content.charAt(i);
+		if (ch === " ") nChars++;
+		else if (ch === "	") nChars += tabSize;
+		else break;
+		i++;
+	}
+	return Math.floor(nChars / tabSize);
+}
+__name(computeIndentLevel, "computeIndentLevel");
+function getEOL(options, text) {
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charAt(i);
+		if (ch === "\r") {
+			if (i + 1 < text.length && text.charAt(i + 1) === "\n") return "\r\n";
+			return "\r";
+		} else if (ch === "\n") return "\n";
+	}
+	return options && options.eol || "\n";
+}
+__name(getEOL, "getEOL");
+function isEOL(text, offset) {
+	return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+__name(isEOL, "isEOL");
+var ParseOptions;
+(function(ParseOptions2) {
+	ParseOptions2.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentProperty = null;
+	let currentParent = [];
+	const previousParents = [];
+	function onValue(value) {
+		if (Array.isArray(currentParent)) currentParent.push(value);
+		else if (currentProperty !== null) currentParent[currentProperty] = value;
+	}
+	__name(onValue, "onValue");
+	visit(text, {
+		onObjectBegin: /* @__PURE__ */ __name(() => {
+			const object = {};
+			onValue(object);
+			previousParents.push(currentParent);
+			currentParent = object;
+			currentProperty = null;
+		}, "onObjectBegin"),
+		onObjectProperty: /* @__PURE__ */ __name((name) => {
+			currentProperty = name;
+		}, "onObjectProperty"),
+		onObjectEnd: /* @__PURE__ */ __name(() => {
+			currentParent = previousParents.pop();
+		}, "onObjectEnd"),
+		onArrayBegin: /* @__PURE__ */ __name(() => {
+			const array = [];
+			onValue(array);
+			previousParents.push(currentParent);
+			currentParent = array;
+			currentProperty = null;
+		}, "onArrayBegin"),
+		onArrayEnd: /* @__PURE__ */ __name(() => {
+			currentParent = previousParents.pop();
+		}, "onArrayEnd"),
+		onLiteralValue: onValue,
+		onError: /* @__PURE__ */ __name((error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}, "onError")
+	}, options);
+	return currentParent[0];
+}
+__name(parse, "parse");
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+	let currentParent = {
+		type: "array",
+		offset: -1,
+		length: -1,
+		children: [],
+		parent: void 0
+	};
+	function ensurePropertyComplete(endOffset) {
+		if (currentParent.type === "property") {
+			currentParent.length = endOffset - currentParent.offset;
+			currentParent = currentParent.parent;
+		}
+	}
+	__name(ensurePropertyComplete, "ensurePropertyComplete");
+	function onValue(valueNode) {
+		currentParent.children.push(valueNode);
+		return valueNode;
+	}
+	__name(onValue, "onValue");
+	visit(text, {
+		onObjectBegin: /* @__PURE__ */ __name((offset) => {
+			currentParent = onValue({
+				type: "object",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		}, "onObjectBegin"),
+		onObjectProperty: /* @__PURE__ */ __name((name, offset, length) => {
+			currentParent = onValue({
+				type: "property",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+			currentParent.children.push({
+				type: "string",
+				value: name,
+				offset,
+				length,
+				parent: currentParent
+			});
+		}, "onObjectProperty"),
+		onObjectEnd: /* @__PURE__ */ __name((offset, length) => {
+			ensurePropertyComplete(offset + length);
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		}, "onObjectEnd"),
+		onArrayBegin: /* @__PURE__ */ __name((offset, length) => {
+			currentParent = onValue({
+				type: "array",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		}, "onArrayBegin"),
+		onArrayEnd: /* @__PURE__ */ __name((offset, length) => {
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		}, "onArrayEnd"),
+		onLiteralValue: /* @__PURE__ */ __name((value, offset, length) => {
+			onValue({
+				type: getNodeType(value),
+				offset,
+				length,
+				parent: currentParent,
+				value
+			});
+			ensurePropertyComplete(offset + length);
+		}, "onLiteralValue"),
+		onSeparator: /* @__PURE__ */ __name((sep, offset, length) => {
+			if (currentParent.type === "property") {
+				if (sep === ":") currentParent.colonOffset = offset;
+				else if (sep === ",") ensurePropertyComplete(offset);
+			}
+		}, "onSeparator"),
+		onError: /* @__PURE__ */ __name((error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}, "onError")
+	}, options);
+	const result = currentParent.children[0];
+	if (result) delete result.parent;
+	return result;
+}
+__name(parseTree, "parseTree");
+function findNodeAtLocation(root, path2$1) {
+	if (!root) return;
+	let node = root;
+	for (let segment of path2$1) if (typeof segment === "string") {
+		if (node.type !== "object" || !Array.isArray(node.children)) return;
+		let found = false;
+		for (const propertyNode of node.children) if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+			node = propertyNode.children[1];
+			found = true;
+			break;
+		}
+		if (!found) return;
+	} else {
+		const index = segment;
+		if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) return;
+		node = node.children[index];
+	}
+	return node;
+}
+__name(findNodeAtLocation, "findNodeAtLocation");
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner(text, false);
+	const _jsonPath = [];
+	function toNoArgVisit(visitFunction) {
+		return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	__name(toNoArgVisit, "toNoArgVisit");
+	function toNoArgVisitWithPath(visitFunction) {
+		return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	__name(toNoArgVisitWithPath, "toNoArgVisitWithPath");
+	function toOneArgVisit(visitFunction) {
+		return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	__name(toOneArgVisit, "toOneArgVisit");
+	function toOneArgVisitWithPath(visitFunction) {
+		return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	__name(toOneArgVisitWithPath, "toOneArgVisitWithPath");
+	const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+	const disallowComments = options && options.disallowComments;
+	const allowTrailingComma = options && options.allowTrailingComma;
+	function scanNext() {
+		while (true) {
+			const token = _scanner.scan();
+			switch (_scanner.getTokenError()) {
+				case 4:
+					handleError(14);
+					break;
+				case 5:
+					handleError(15);
+					break;
+				case 3:
+					handleError(13);
+					break;
+				case 1:
+					if (!disallowComments) handleError(11);
+					break;
+				case 2:
+					handleError(12);
+					break;
+				case 6:
+					handleError(16);
+					break;
+			}
+			switch (token) {
+				case 12:
+				case 13:
+					if (disallowComments) handleError(10);
+					else onComment();
+					break;
+				case 16:
+					handleError(1);
+					break;
+				case 15:
+				case 14: break;
+				default: return token;
+			}
+		}
+	}
+	__name(scanNext, "scanNext");
+	function handleError(error, skipUntilAfter = [], skipUntil2 = []) {
+		onError(error);
+		if (skipUntilAfter.length + skipUntil2.length > 0) {
+			let token = _scanner.getToken();
+			while (token !== 17) {
+				if (skipUntilAfter.indexOf(token) !== -1) {
+					scanNext();
+					break;
+				} else if (skipUntil2.indexOf(token) !== -1) break;
+				token = scanNext();
+			}
+		}
+	}
+	__name(handleError, "handleError");
+	function parseString2(isValue) {
+		const value = _scanner.getTokenValue();
+		if (isValue) onLiteralValue(value);
+		else {
+			onObjectProperty(value);
+			_jsonPath.push(value);
+		}
+		scanNext();
+		return true;
+	}
+	__name(parseString2, "parseString");
+	function parseLiteral() {
+		switch (_scanner.getToken()) {
+			case 11:
+				const tokenValue = _scanner.getTokenValue();
+				let value = Number(tokenValue);
+				if (isNaN(value)) {
+					handleError(2);
+					value = 0;
+				}
+				onLiteralValue(value);
+				break;
+			case 7:
+				onLiteralValue(null);
+				break;
+			case 8:
+				onLiteralValue(true);
+				break;
+			case 9:
+				onLiteralValue(false);
+				break;
+			default: return false;
+		}
+		scanNext();
+		return true;
+	}
+	__name(parseLiteral, "parseLiteral");
+	function parseProperty() {
+		if (_scanner.getToken() !== 10) {
+			handleError(3, [], [2, 5]);
+			return false;
+		}
+		parseString2(false);
+		if (_scanner.getToken() === 6) {
+			onSeparator(":");
+			scanNext();
+			if (!parseValue2()) handleError(4, [], [2, 5]);
+		} else handleError(5, [], [2, 5]);
+		_jsonPath.pop();
+		return true;
+	}
+	__name(parseProperty, "parseProperty");
+	function parseObject() {
+		onObjectBegin();
+		scanNext();
+		let needsComma = false;
+		while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 2 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (!parseProperty()) handleError(4, [], [2, 5]);
+			needsComma = true;
+		}
+		onObjectEnd();
+		if (_scanner.getToken() !== 2) handleError(7, [2], []);
+		else scanNext();
+		return true;
+	}
+	__name(parseObject, "parseObject");
+	function parseArray2() {
+		onArrayBegin();
+		scanNext();
+		let isFirstElement = true;
+		let needsComma = false;
+		while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+			if (_scanner.getToken() === 5) {
+				if (!needsComma) handleError(4, [], []);
+				onSeparator(",");
+				scanNext();
+				if (_scanner.getToken() === 4 && allowTrailingComma) break;
+			} else if (needsComma) handleError(6, [], []);
+			if (isFirstElement) {
+				_jsonPath.push(0);
+				isFirstElement = false;
+			} else _jsonPath[_jsonPath.length - 1]++;
+			if (!parseValue2()) handleError(4, [], [4, 5]);
+			needsComma = true;
+		}
+		onArrayEnd();
+		if (!isFirstElement) _jsonPath.pop();
+		if (_scanner.getToken() !== 4) handleError(8, [4], []);
+		else scanNext();
+		return true;
+	}
+	__name(parseArray2, "parseArray");
+	function parseValue2() {
+		switch (_scanner.getToken()) {
+			case 3: return parseArray2();
+			case 1: return parseObject();
+			case 10: return parseString2(true);
+			default: return parseLiteral();
+		}
+	}
+	__name(parseValue2, "parseValue");
+	scanNext();
+	if (_scanner.getToken() === 17) {
+		if (options.allowEmptyContent) return true;
+		handleError(4, [], []);
+		return false;
+	}
+	if (!parseValue2()) {
+		handleError(4, [], []);
+		return false;
+	}
+	if (_scanner.getToken() !== 17) handleError(9, [], []);
+	return true;
+}
+__name(visit, "visit");
+function getNodeType(value) {
+	switch (typeof value) {
+		case "boolean": return "boolean";
+		case "number": return "number";
+		case "string": return "string";
+		case "object":
+			if (!value) return "null";
+			else if (Array.isArray(value)) return "array";
+			return "object";
+		default: return "null";
+	}
+}
+__name(getNodeType, "getNodeType");
+function setProperty(text, originalPath, value, options) {
+	const path2$1 = originalPath.slice();
+	const root = parseTree(text, []);
+	let parent = void 0;
+	let lastSegment = void 0;
+	while (path2$1.length > 0) {
+		lastSegment = path2$1.pop();
+		parent = findNodeAtLocation(root, path2$1);
+		if (parent === void 0 && value !== void 0) if (typeof lastSegment === "string") value = { [lastSegment]: value };
+		else value = [value];
+		else break;
+	}
+	if (!parent) {
+		if (value === void 0) throw new Error("Can not delete in empty document");
+		return withFormatting(text, {
+			offset: root ? root.offset : 0,
+			length: root ? root.length : 0,
+			content: JSON.stringify(value)
+		}, options);
+	} else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+		const existing = findNodeAtLocation(parent, [lastSegment]);
+		if (existing !== void 0) if (value === void 0) {
+			if (!existing.parent) throw new Error("Malformed AST");
+			const propertyIndex = parent.children.indexOf(existing.parent);
+			let removeBegin;
+			let removeEnd = existing.parent.offset + existing.parent.length;
+			if (propertyIndex > 0) {
+				let previous = parent.children[propertyIndex - 1];
+				removeBegin = previous.offset + previous.length;
+			} else {
+				removeBegin = parent.offset + 1;
+				if (parent.children.length > 1) removeEnd = parent.children[1].offset;
+			}
+			return withFormatting(text, {
+				offset: removeBegin,
+				length: removeEnd - removeBegin,
+				content: ""
+			}, options);
+		} else return withFormatting(text, {
+			offset: existing.offset,
+			length: existing.length,
+			content: JSON.stringify(value)
+		}, options);
+		else {
+			if (value === void 0) return [];
+			const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+			const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+			let edit;
+			if (index > 0) {
+				let previous = parent.children[index - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			} else if (parent.children.length === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty
+			};
+			else edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty + ","
+			};
+			return withFormatting(text, edit, options);
+		}
+	} else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+		const insertIndex = lastSegment;
+		if (insertIndex === -1) {
+			const newProperty = `${JSON.stringify(value)}`;
+			let edit;
+			if (parent.children.length === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: newProperty
+			};
+			else {
+				const previous = parent.children[parent.children.length - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			}
+			return withFormatting(text, edit, options);
+		} else if (value === void 0 && parent.children.length >= 0) {
+			const removalIndex = lastSegment;
+			const toRemove = parent.children[removalIndex];
+			let edit;
+			if (parent.children.length === 1) edit = {
+				offset: parent.offset + 1,
+				length: parent.length - 2,
+				content: ""
+			};
+			else if (parent.children.length - 1 === removalIndex) {
+				let previous = parent.children[removalIndex - 1];
+				let offset = previous.offset + previous.length;
+				edit = {
+					offset,
+					length: parent.offset + parent.length - 2 - offset,
+					content: ""
+				};
+			} else edit = {
+				offset: toRemove.offset,
+				length: parent.children[removalIndex + 1].offset - toRemove.offset,
+				content: ""
+			};
+			return withFormatting(text, edit, options);
+		} else if (value !== void 0) {
+			let edit;
+			const newProperty = `${JSON.stringify(value)}`;
+			if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+				const toModify = parent.children[lastSegment];
+				edit = {
+					offset: toModify.offset,
+					length: toModify.length,
+					content: newProperty
+				};
+			} else if (parent.children.length === 0 || lastSegment === 0) edit = {
+				offset: parent.offset + 1,
+				length: 0,
+				content: parent.children.length === 0 ? newProperty : newProperty + ","
+			};
+			else {
+				const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+				const previous = parent.children[index - 1];
+				edit = {
+					offset: previous.offset + previous.length,
+					length: 0,
+					content: "," + newProperty
+				};
+			}
+			return withFormatting(text, edit, options);
+		} else throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+	} else throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+}
+__name(setProperty, "setProperty");
+function withFormatting(text, edit, options) {
+	if (!options.formattingOptions) return [edit];
+	let newText = applyEdit(text, edit);
+	let begin = edit.offset;
+	let end = edit.offset + edit.content.length;
+	if (edit.length === 0 || edit.content.length === 0) {
+		while (begin > 0 && !isEOL(newText, begin - 1)) begin--;
+		while (end < newText.length && !isEOL(newText, end)) end++;
+	}
+	const edits = format(newText, {
+		offset: begin,
+		length: end - begin
+	}, {
+		...options.formattingOptions,
+		keepLines: false
+	});
+	for (let i = edits.length - 1; i >= 0; i--) {
+		const edit2 = edits[i];
+		newText = applyEdit(newText, edit2);
+		begin = Math.min(begin, edit2.offset);
+		end = Math.max(end, edit2.offset + edit2.length);
+		end += edit2.content.length - edit2.length;
+	}
+	const editLength = text.length - (newText.length - end) - begin;
+	return [{
+		offset: begin,
+		length: editLength,
+		content: newText.substring(begin, end)
+	}];
+}
+__name(withFormatting, "withFormatting");
+function applyEdit(text, edit) {
+	return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+__name(applyEdit, "applyEdit");
+var ScanError;
+(function(ScanError2) {
+	ScanError2[ScanError2["None"] = 0] = "None";
+	ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+	ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+	ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+	ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+	ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+	ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+	SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+	SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+	SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+	SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+	SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+	SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+	SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+	SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+	SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+	SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+	SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+	SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+	SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+	SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+	SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+	SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+	SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+	ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+	ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+	ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+	ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+	ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+	ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+	ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+	ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+	ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+	ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+	ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+	ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+	ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+	ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+	ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+	ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+	switch (code) {
+		case 1: return "InvalidSymbol";
+		case 2: return "InvalidNumberFormat";
+		case 3: return "PropertyNameExpected";
+		case 4: return "ValueExpected";
+		case 5: return "ColonExpected";
+		case 6: return "CommaExpected";
+		case 7: return "CloseBraceExpected";
+		case 8: return "CloseBracketExpected";
+		case 9: return "EndOfFileExpected";
+		case 10: return "InvalidCommentToken";
+		case 11: return "UnexpectedEndOfComment";
+		case 12: return "UnexpectedEndOfString";
+		case 13: return "UnexpectedEndOfNumber";
+		case 14: return "InvalidUnicode";
+		case 15: return "InvalidEscapeCharacter";
+		case 16: return "InvalidCharacter";
+	}
+	return "<unknown ParseErrorCode>";
+}
+__name(printParseErrorCode, "printParseErrorCode");
+function format2(documentText, range, options) {
+	return format(documentText, range, options);
+}
+__name(format2, "format");
+function modify(text, path2$1, value, options) {
+	return setProperty(text, path2$1, value, options);
+}
+__name(modify, "modify");
+function applyEdits(text, edits) {
+	let sortedEdits = edits.slice(0).sort((a, b) => {
+		const diff = a.offset - b.offset;
+		if (diff === 0) return a.length - b.length;
+		return diff;
+	});
+	let lastModifiedOffset = text.length;
+	for (let i = sortedEdits.length - 1; i >= 0; i--) {
+		let e = sortedEdits[i];
+		if (e.offset + e.length <= lastModifiedOffset) text = applyEdit(text, e);
+		else throw new Error("Overlapping edit");
+		lastModifiedOffset = e.offset;
+	}
+	return text;
+}
+__name(applyEdits, "applyEdits");
+function getLineColFromPtr(string, ptr) {
+	let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+	return [lines.length, lines.pop().length + 1];
+}
+__name(getLineColFromPtr, "getLineColFromPtr");
+function makeCodeBlock(string, line, column) {
+	let lines = string.split(/\r\n|\n|\r/g);
+	let codeblock = "";
+	let numberLen = (Math.log10(line + 1) | 0) + 1;
+	for (let i = line - 1; i <= line + 1; i++) {
+		let l = lines[i - 1];
+		if (!l) continue;
+		codeblock += i.toString().padEnd(numberLen, " ");
+		codeblock += ":  ";
+		codeblock += l;
+		codeblock += "\n";
+		if (i === line) {
+			codeblock += " ".repeat(numberLen + column + 2);
+			codeblock += "^\n";
+		}
+	}
+	return codeblock;
+}
+__name(makeCodeBlock, "makeCodeBlock");
+var TomlError = class extends Error {
+	static {
+		__name(this, "TomlError");
+	}
+	line;
+	column;
+	codeblock;
+	constructor(message, options) {
+		const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+		const codeblock = makeCodeBlock(options.toml, line, column);
+		super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+		this.line = line;
+		this.column = column;
+		this.codeblock = codeblock;
+	}
+};
+function isEscaped(str, ptr) {
+	let i = 0;
+	while (str[ptr - ++i] === "\\");
+	return --i && i % 2;
+}
+__name(isEscaped, "isEscaped");
+function indexOfNewline(str, start = 0, end = str.length) {
+	let idx = str.indexOf("\n", start);
+	if (str[idx - 1] === "\r") idx--;
+	return idx <= end ? idx : -1;
+}
+__name(indexOfNewline, "indexOfNewline");
+function skipComment(str, ptr) {
+	for (let i = ptr; i < str.length; i++) {
+		let c = str[i];
+		if (c === "\n") return i;
+		if (c === "\r" && str[i + 1] === "\n") return i + 1;
+		if (c < " " && c !== "	" || c === "") throw new TomlError("control characters are not allowed in comments", {
+			toml: str,
+			ptr
+		});
+	}
+	return str.length;
+}
+__name(skipComment, "skipComment");
+function skipVoid(str, ptr, banNewLines, banComments) {
+	let c;
+	while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n")) ptr++;
+	return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+__name(skipVoid, "skipVoid");
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+	if (!end) {
+		ptr = indexOfNewline(str, ptr);
+		return ptr < 0 ? str.length : ptr;
+	}
+	for (let i = ptr; i < str.length; i++) {
+		let c = str[i];
+		if (c === "#") i = indexOfNewline(str, i);
+		else if (c === sep) return i + 1;
+		else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) return i;
+	}
+	throw new TomlError("cannot find end of structure", {
+		toml: str,
+		ptr
+	});
+}
+__name(skipUntil, "skipUntil");
+function getStringEnd(str, seek) {
+	let first = str[seek];
+	let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+	seek += target.length - 1;
+	do
+		seek = str.indexOf(target, ++seek);
+	while (seek > -1 && first !== "'" && isEscaped(str, seek));
+	if (seek > -1) {
+		seek += target.length;
+		if (target.length > 1) {
+			if (str[seek] === first) seek++;
+			if (str[seek] === first) seek++;
+		}
+	}
+	return seek;
+}
+__name(getStringEnd, "getStringEnd");
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}:\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+	static {
+		__name(this, "TomlDate");
+	}
+	#hasDate = false;
+	#hasTime = false;
+	#offset = null;
+	constructor(date) {
+		let hasDate = true;
+		let hasTime = true;
+		let offset = "Z";
+		if (typeof date === "string") {
+			let match = date.match(DATE_TIME_RE);
+			if (match) {
+				if (!match[1]) {
+					hasDate = false;
+					date = `0000-01-01T${date}`;
+				}
+				hasTime = !!match[2];
+				hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+				if (match[2] && +match[2] > 23) date = "";
+				else {
+					offset = match[3] || null;
+					date = date.toUpperCase();
+					if (!offset && hasTime) date += "Z";
+				}
+			} else date = "";
+		}
+		super(date);
+		if (!isNaN(this.getTime())) {
+			this.#hasDate = hasDate;
+			this.#hasTime = hasTime;
+			this.#offset = offset;
+		}
+	}
+	isDateTime() {
+		return this.#hasDate && this.#hasTime;
+	}
+	isLocal() {
+		return !this.#hasDate || !this.#hasTime || !this.#offset;
+	}
+	isDate() {
+		return this.#hasDate && !this.#hasTime;
+	}
+	isTime() {
+		return this.#hasTime && !this.#hasDate;
+	}
+	isValid() {
+		return this.#hasDate || this.#hasTime;
+	}
+	toISOString() {
+		let iso = super.toISOString();
+		if (this.isDate()) return iso.slice(0, 10);
+		if (this.isTime()) return iso.slice(11, 23);
+		if (this.#offset === null) return iso.slice(0, -1);
+		if (this.#offset === "Z") return iso;
+		let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+		offset = this.#offset[0] === "-" ? offset : -offset;
+		return (/* @__PURE__ */ new Date(this.getTime() - offset * 6e4)).toISOString().slice(0, -1) + this.#offset;
+	}
+	static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+		let date = new _TomlDate(jsDate);
+		date.#offset = offset;
+		return date;
+	}
+	static wrapAsLocalDateTime(jsDate) {
+		let date = new _TomlDate(jsDate);
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalDate(jsDate) {
+		let date = new _TomlDate(jsDate);
+		date.#hasTime = false;
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalTime(jsDate) {
+		let date = new _TomlDate(jsDate);
+		date.#hasDate = false;
+		date.#offset = null;
+		return date;
+	}
+};
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{4,8}$/i;
+var ESC_MAP = {
+	b: "\b",
+	t: "	",
+	n: "\n",
+	f: "\f",
+	r: "\r",
+	"\"": "\"",
+	"\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+	let isLiteral = str[ptr] === "'";
+	let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+	if (isMultiline) {
+		endPtr -= 2;
+		if (str[ptr += 2] === "\r") ptr++;
+		if (str[ptr] === "\n") ptr++;
+	}
+	let tmp = 0;
+	let isEscape;
+	let parsed = "";
+	let sliceStart = ptr;
+	while (ptr < endPtr - 1) {
+		let c = str[ptr++];
+		if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+			if (!isMultiline) throw new TomlError("newlines are not allowed in strings", {
+				toml: str,
+				ptr: ptr - 1
+			});
+		} else if (c < " " && c !== "	" || c === "") throw new TomlError("control characters are not allowed in strings", {
+			toml: str,
+			ptr: ptr - 1
+		});
+		if (isEscape) {
+			isEscape = false;
+			if (c === "u" || c === "U") {
+				let code = str.slice(ptr, ptr += c === "u" ? 4 : 8);
+				if (!ESCAPE_REGEX.test(code)) throw new TomlError("invalid unicode escape", {
+					toml: str,
+					ptr: tmp
+				});
+				try {
+					parsed += String.fromCodePoint(parseInt(code, 16));
+				} catch {
+					throw new TomlError("invalid unicode escape", {
+						toml: str,
+						ptr: tmp
+					});
+				}
+			} else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+				ptr = skipVoid(str, ptr - 1, true);
+				if (str[ptr] !== "\n" && str[ptr] !== "\r") throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+					toml: str,
+					ptr: tmp
+				});
+				ptr = skipVoid(str, ptr);
+			} else if (c in ESC_MAP) parsed += ESC_MAP[c];
+			else throw new TomlError("unrecognized escape sequence", {
+				toml: str,
+				ptr: tmp
+			});
+			sliceStart = ptr;
+		} else if (!isLiteral && c === "\\") {
+			tmp = ptr - 1;
+			isEscape = true;
+			parsed += str.slice(sliceStart, tmp);
+		}
+	}
+	return parsed + str.slice(sliceStart, endPtr - 1);
+}
+__name(parseString, "parseString");
+function parseValue(value, toml, ptr, integersAsBigInt) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "-inf") return -Infinity;
+	if (value === "inf" || value === "+inf") return Infinity;
+	if (value === "nan" || value === "+nan" || value === "-nan") return NaN;
+	if (value === "-0") return integersAsBigInt ? 0n : 0;
+	let isInt = INT_REGEX.test(value);
+	if (isInt || FLOAT_REGEX.test(value)) {
+		if (LEADING_ZERO.test(value)) throw new TomlError("leading zeroes are not allowed", {
+			toml,
+			ptr
+		});
+		value = value.replace(/_/g, "");
+		let numeric = +value;
+		if (isNaN(numeric)) throw new TomlError("invalid number", {
+			toml,
+			ptr
+		});
+		if (isInt) {
+			if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) throw new TomlError("integer value cannot be represented losslessly", {
+				toml,
+				ptr
+			});
+			if (isInt || integersAsBigInt === true) numeric = BigInt(value);
+		}
+		return numeric;
+	}
+	const date = new TomlDate(value);
+	if (!date.isValid()) throw new TomlError("invalid value", {
+		toml,
+		ptr
+	});
+	return date;
+}
+__name(parseValue, "parseValue");
+function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
+	let value = str.slice(startPtr, endPtr);
+	let commentIdx = value.indexOf("#");
+	if (commentIdx > -1) {
+		skipComment(str, commentIdx);
+		value = value.slice(0, commentIdx);
+	}
+	let trimmed = value.trimEnd();
+	if (!allowNewLines) {
+		let newlineIdx = value.indexOf("\n", trimmed.length);
+		if (newlineIdx > -1) throw new TomlError("newlines are not allowed in inline tables", {
+			toml: str,
+			ptr: startPtr + newlineIdx
+		});
+	}
+	return [trimmed, commentIdx];
+}
+__name(sliceAndTrimEndOf, "sliceAndTrimEndOf");
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+	if (depth === 0) throw new TomlError("document contains excessively nested structures. aborting.", {
+		toml: str,
+		ptr
+	});
+	let c = str[ptr];
+	if (c === "[" || c === "{") {
+		let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+		let newPtr = end ? skipUntil(str, endPtr2, ",", end) : endPtr2;
+		if (endPtr2 - newPtr && end === "}") {
+			let nextNewLine = indexOfNewline(str, endPtr2, newPtr);
+			if (nextNewLine > -1) throw new TomlError("newlines are not allowed in inline tables", {
+				toml: str,
+				ptr: nextNewLine
+			});
+		}
+		return [value, newPtr];
+	}
+	let endPtr;
+	if (c === "\"" || c === "'") {
+		endPtr = getStringEnd(str, ptr);
+		let parsed = parseString(str, ptr, endPtr);
+		if (end) {
+			endPtr = skipVoid(str, endPtr, end !== "]");
+			if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") throw new TomlError("unexpected character encountered", {
+				toml: str,
+				ptr: endPtr
+			});
+			endPtr += +(str[endPtr] === ",");
+		}
+		return [parsed, endPtr];
+	}
+	endPtr = skipUntil(str, ptr, ",", end);
+	let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","), end === "]");
+	if (!slice[0]) throw new TomlError("incomplete key-value declaration: no value specified", {
+		toml: str,
+		ptr
+	});
+	if (end && slice[1] > -1) {
+		endPtr = skipVoid(str, ptr + slice[1]);
+		endPtr += +(str[endPtr] === ",");
+	}
+	return [parseValue(slice[0], str, ptr, integersAsBigInt), endPtr];
+}
+__name(extractValue, "extractValue");
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+	let dot = ptr - 1;
+	let parsed = [];
+	let endPtr = str.indexOf(end, ptr);
+	if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+		toml: str,
+		ptr
+	});
+	do {
+		let c = str[ptr = ++dot];
+		if (c !== " " && c !== "	") if (c === "\"" || c === "'") {
+			if (c === str[ptr + 1] && c === str[ptr + 2]) throw new TomlError("multiline strings are not allowed in keys", {
+				toml: str,
+				ptr
+			});
+			let eos = getStringEnd(str, ptr);
+			if (eos < 0) throw new TomlError("unfinished string encountered", {
+				toml: str,
+				ptr
+			});
+			dot = str.indexOf(".", eos);
+			let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+			let newLine = indexOfNewline(strEnd);
+			if (newLine > -1) throw new TomlError("newlines are not allowed in keys", {
+				toml: str,
+				ptr: ptr + dot + newLine
+			});
+			if (strEnd.trimStart()) throw new TomlError("found extra tokens after the string part", {
+				toml: str,
+				ptr: eos
+			});
+			if (endPtr < eos) {
+				endPtr = str.indexOf(end, eos);
+				if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+					toml: str,
+					ptr
+				});
+			}
+			parsed.push(parseString(str, ptr, eos));
+		} else {
+			dot = str.indexOf(".", ptr);
+			let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+			if (!KEY_PART_RE.test(part)) throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+				toml: str,
+				ptr
+			});
+			parsed.push(part.trimEnd());
+		}
+	} while (dot + 1 && dot < endPtr);
+	return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+__name(parseKey, "parseKey");
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+	let res = {};
+	let seen = /* @__PURE__ */ new Set();
+	let c;
+	let comma = 0;
+	ptr++;
+	while ((c = str[ptr++]) !== "}" && c) {
+		let err = {
+			toml: str,
+			ptr: ptr - 1
+		};
+		if (c === "\n") throw new TomlError("newlines are not allowed in inline tables", err);
+		else if (c === "#") throw new TomlError("inline tables cannot contain comments", err);
+		else if (c === ",") throw new TomlError("expected key-value, found comma", err);
+		else if (c !== " " && c !== "	") {
+			let k;
+			let t = res;
+			let hasOwn = false;
+			let [key, keyEndPtr] = parseKey(str, ptr - 1);
+			for (let i = 0; i < key.length; i++) {
+				if (i) t = hasOwn ? t[k] : t[k] = {};
+				k = key[i];
+				if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) throw new TomlError("trying to redefine an already defined value", {
+					toml: str,
+					ptr
+				});
+				if (!hasOwn && k === "__proto__") Object.defineProperty(t, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			if (hasOwn) throw new TomlError("trying to redefine an already defined value", {
+				toml: str,
+				ptr
+			});
+			let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+			seen.add(value);
+			t[k] = value;
+			ptr = valueEndPtr;
+			comma = str[ptr - 1] === "," ? ptr - 1 : 0;
+		}
+	}
+	if (comma) throw new TomlError("trailing commas are not allowed in inline tables", {
+		toml: str,
+		ptr: comma
+	});
+	if (!c) throw new TomlError("unfinished table encountered", {
+		toml: str,
+		ptr
+	});
+	return [res, ptr];
+}
+__name(parseInlineTable, "parseInlineTable");
+function parseArray(str, ptr, depth, integersAsBigInt) {
+	let res = [];
+	let c;
+	ptr++;
+	while ((c = str[ptr++]) !== "]" && c) if (c === ",") throw new TomlError("expected value, found comma", {
+		toml: str,
+		ptr: ptr - 1
+	});
+	else if (c === "#") ptr = skipComment(str, ptr);
+	else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+		let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+		res.push(e[0]);
+		ptr = e[1];
+	}
+	if (!c) throw new TomlError("unfinished array encountered", {
+		toml: str,
+		ptr
+	});
+	return [res, ptr];
+}
+__name(parseArray, "parseArray");
+function peekTable(key, table, meta, type) {
+	let t = table;
+	let m = meta;
+	let k;
+	let hasOwn = false;
+	let state;
+	for (let i = 0; i < key.length; i++) {
+		if (i) {
+			t = hasOwn ? t[k] : t[k] = {};
+			m = (state = m[k]).c;
+			if (type === 0 && (state.t === 1 || state.t === 2)) return null;
+			if (state.t === 2) {
+				let l = t.length - 1;
+				t = t[l];
+				m = m[l].c;
+			}
+		}
+		k = key[i];
+		if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) return null;
+		if (!hasOwn) {
+			if (k === "__proto__") {
+				Object.defineProperty(t, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+				Object.defineProperty(m, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			m[k] = {
+				t: i < key.length - 1 && type === 2 ? 3 : type,
+				d: false,
+				i: 0,
+				c: {}
+			};
+		}
+	}
+	state = m[k];
+	if (state.t !== type && !(type === 1 && state.t === 3)) return null;
+	if (type === 2) {
+		if (!state.d) {
+			state.d = true;
+			t[k] = [];
+		}
+		t[k].push(t = {});
+		state.c[state.i++] = state = {
+			t: 1,
+			d: false,
+			i: 0,
+			c: {}
+		};
+	}
+	if (state.d) return null;
+	state.d = true;
+	if (type === 1) t = hasOwn ? t[k] : t[k] = {};
+	else if (type === 0 && hasOwn) return null;
+	return [
+		k,
+		t,
+		state.c
+	];
+}
+__name(peekTable, "peekTable");
+function parse3(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+	let res = {};
+	let meta = {};
+	let tbl = res;
+	let m = meta;
+	for (let ptr = skipVoid(toml, 0); ptr < toml.length;) {
+		if (toml[ptr] === "[") {
+			let isTableArray = toml[++ptr] === "[";
+			let k = parseKey(toml, ptr += +isTableArray, "]");
+			if (isTableArray) {
+				if (toml[k[1] - 1] !== "]") throw new TomlError("expected end of table declaration", {
+					toml,
+					ptr: k[1] - 1
+				});
+				k[1]++;
+			}
+			let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr
+			});
+			m = p[2];
+			tbl = p[1];
+			ptr = k[1];
+		} else {
+			let k = parseKey(toml, ptr);
+			let p = peekTable(k[0], tbl, m, 0);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr
+			});
+			let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+			p[1][p[0]] = v[0];
+			ptr = v[1];
+		}
+		ptr = skipVoid(toml, ptr, true);
+		if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+			toml,
+			ptr
+		});
+		ptr = skipVoid(toml, ptr);
+	}
+	return res;
+}
+__name(parse3, "parse");
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+	let type = typeof obj;
+	if (type === "object") {
+		if (Array.isArray(obj)) return "array";
+		if (obj instanceof Date) return "date";
+	}
+	return type;
+}
+__name(extendedTypeOf, "extendedTypeOf");
+function isArrayOfTables(obj) {
+	for (let i = 0; i < obj.length; i++) if (extendedTypeOf(obj[i]) !== "object") return false;
+	return obj.length != 0;
+}
+__name(isArrayOfTables, "isArrayOfTables");
+function formatString(s) {
+	return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+__name(formatString, "formatString");
+function stringifyValue(val, type, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	if (type === "number") {
+		if (isNaN(val)) return "nan";
+		if (val === Infinity) return "inf";
+		if (val === -Infinity) return "-inf";
+		if (numberAsFloat && Number.isInteger(val)) return val.toFixed(1);
+		return val.toString();
+	}
+	if (type === "bigint" || type === "boolean") return val.toString();
+	if (type === "string") return formatString(val);
+	if (type === "date") {
+		if (isNaN(val.getTime())) throw new TypeError("cannot serialize invalid date");
+		return val.toISOString();
+	}
+	if (type === "object") return stringifyInlineTable(val, depth, numberAsFloat);
+	if (type === "array") return stringifyArray(val, depth, numberAsFloat);
+}
+__name(stringifyValue, "stringifyValue");
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+	let keys = Object.keys(obj);
+	if (keys.length === 0) return "{}";
+	let res = "{ ";
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (i) res += ", ";
+		res += BARE_KEY.test(k) ? k : formatString(k);
+		res += " = ";
+		res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+	}
+	return res + " }";
+}
+__name(stringifyInlineTable, "stringifyInlineTable");
+function stringifyArray(array, depth, numberAsFloat) {
+	if (array.length === 0) return "[]";
+	let res = "[ ";
+	for (let i = 0; i < array.length; i++) {
+		if (i) res += ", ";
+		if (array[i] === null || array[i] === void 0) throw new TypeError("arrays cannot contain null or undefined values");
+		res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+	}
+	return res + " ]";
+}
+__name(stringifyArray, "stringifyArray");
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let res = "";
+	for (let i = 0; i < array.length; i++) {
+		res += `${res && "\n"}[[${key}]]
+`;
+		res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+	}
+	return res;
+}
+__name(stringifyArrayTable, "stringifyArrayTable");
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+	if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+	let preamble = "";
+	let tables = "";
+	let keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i];
+		if (obj[k] !== null && obj[k] !== void 0) {
+			let type = extendedTypeOf(obj[k]);
+			if (type === "symbol" || type === "function") throw new TypeError(`cannot serialize values of type '${type}'`);
+			let key = BARE_KEY.test(k) ? k : formatString(k);
+			if (type === "array" && isArrayOfTables(obj[k])) tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+			else if (type === "object") {
+				let tblKey = prefix ? `${prefix}.${key}` : key;
+				tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+			} else {
+				preamble += key;
+				preamble += " = ";
+				preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+				preamble += "\n";
+			}
+		}
+	}
+	if (tableKey && (preamble || !tables)) preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+	return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+__name(stringifyTable, "stringifyTable");
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+	if (extendedTypeOf(obj) !== "object") throw new TypeError("stringify can only be called with an object");
+	let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+	if (str[str.length - 1] !== "\n") return str + "\n";
+	return str;
+}
+__name(stringify, "stringify");
+var dist_default = {
+	parse: parse3,
+	stringify,
+	TomlDate,
+	TomlError
+};
+var ParseError = class extends UserError {
+	static {
+		__name(this, "ParseError");
+	}
+	text;
+	notes;
+	location;
+	kind;
+	constructor({ text, notes, location, kind, telemetryMessage }) {
+		super(text, { telemetryMessage });
+		this.name = this.constructor.name;
+		this.text = text;
+		this.notes = notes ?? [];
+		this.location = location;
+		this.kind = kind ?? "error";
+	}
+};
+var APIError = class extends ParseError {
+	static {
+		__name(this, "APIError");
+	}
+	#status;
+	code;
+	accountTag;
+	/**
+	* Optional structured metadata hoisted from the first `FetchError.meta`
+	* on the v4 response envelope. Consumers can inspect this to render
+	* endpoint-specific structured error payloads.
+	*/
+	meta;
+	constructor({ status,...rest }) {
+		super(rest);
+		this.name = this.constructor.name;
+		this.#status = status;
+	}
+	get status() {
+		return this.#status;
+	}
+	isGatewayError() {
+		if (this.#status !== void 0) return [524].includes(this.#status);
+		return false;
+	}
+	isRetryable() {
+		return String(this.#status).startsWith("5");
+	}
+	#reportable = true;
+	get reportable() {
+		return this.#reportable;
+	}
+	preventReport() {
+		this.#reportable = false;
+	}
+};
+function parseTOML(tomlContent, filePath) {
+	try {
+		return dist_default.parse(tomlContent);
+	} catch (err) {
+		if (!(err instanceof TomlError)) throw err;
+		const location = {
+			lineText: tomlContent.split("\n")[err.line - 1],
+			line: err.line,
+			column: err.column - 1,
+			file: filePath,
+			fileText: tomlContent
+		};
+		throw new ParseError({
+			text: err.message.substring(0, err.message.indexOf("\n")),
+			location,
+			telemetryMessage: "TOML parse error"
+		});
+	}
+}
+__name(parseTOML, "parseTOML");
+function parsePackageJSON(input, file2) {
+	return parseJSON(input, file2);
+}
+__name(parsePackageJSON, "parsePackageJSON");
+function parseJSON(input, file2) {
+	return parseJSONC(input, file2, {
+		allowEmptyContent: false,
+		allowTrailingComma: false,
+		disallowComments: true
+	});
+}
+__name(parseJSON, "parseJSON");
+function parseJSONC(input, file2, options = { allowTrailingComma: true }) {
+	const errors = [];
+	const data = parse2(input, errors, options);
+	if (errors.length) throw new ParseError({
+		text: printParseErrorCode(errors[0].error),
+		location: {
+			...indexLocation({
+				file: file2,
+				fileText: input
+			}, errors[0].offset + 1),
+			length: errors[0].length
+		},
+		telemetryMessage: "JSON(C) parse error"
+	});
+	return data;
+}
+__name(parseJSONC, "parseJSONC");
+function readFileSyncToBuffer(file2) {
+	try {
+		return readFileSync(file2);
+	} catch (err) {
+		const { message } = err;
+		throw new ParseError({
+			text: `Could not read file: ${file2}`,
+			notes: [{ text: message.replace(file2, resolve(file2)) }],
+			telemetryMessage: false
+		});
+	}
+}
+__name(readFileSyncToBuffer, "readFileSyncToBuffer");
+function readFileSync$1(file2) {
+	try {
+		return removeBOMAndValidate(readFileSync(file2), file2);
+	} catch (err) {
+		if (err instanceof ParseError) throw err;
+		const { message } = err;
+		throw new ParseError({
+			text: `Could not read file: ${file2}`,
+			notes: [{ text: message.replace(file2, resolve(file2)) }],
+			telemetryMessage: "Could not read file"
+		});
+	}
+}
+__name(readFileSync$1, "readFileSync");
+function indexLocation(file2, index) {
+	let lineText, line = 0, column = 0, cursor = 0;
+	const { fileText = "" } = file2;
+	for (const row of fileText.split("\n")) {
+		line++;
+		cursor += row.length + 1;
+		if (cursor >= index) {
+			lineText = row;
+			column = row.length - (cursor - index);
+			break;
+		}
+	}
+	return {
+		lineText,
+		line,
+		column,
+		...file2
+	};
+}
+__name(indexLocation, "indexLocation");
+function searchLocation(file2, query) {
+	let lineText, length, line = 0, column = 0;
+	const queryText = String(query);
+	const { fileText = "" } = file2;
+	for (const content of fileText.split("\n")) {
+		line++;
+		const index = content.indexOf(queryText);
+		if (index >= 0) {
+			lineText = content;
+			column = index;
+			length = queryText.length;
+			break;
+		}
+	}
+	return {
+		lineText,
+		line,
+		column,
+		length,
+		...file2
+	};
+}
+__name(searchLocation, "searchLocation");
+var units = {
+	nanoseconds: 1e-9,
+	nanosecond: 1e-9,
+	microseconds: 1e-6,
+	microsecond: 1e-6,
+	milliseconds: .001,
+	millisecond: .001,
+	seconds: 1,
+	second: 1,
+	minutes: 60,
+	minute: 60,
+	hours: 3600,
+	hour: 3600,
+	days: 86400,
+	day: 86400,
+	weeks: 604800,
+	week: 604800,
+	month: 18144e3,
+	year: 220752e3,
+	nsecs: 1e-9,
+	nsec: 1e-9,
+	usecs: 1e-6,
+	usec: 1e-6,
+	msecs: .001,
+	msec: .001,
+	secs: 1,
+	sec: 1,
+	mins: 60,
+	min: 60,
+	ns: 1e-9,
+	us: 1e-6,
+	ms: .001,
+	mo: 18144e3,
+	yr: 220752e3,
+	s: 1,
+	m: 60,
+	h: 3600,
+	d: 86400,
+	w: 604800,
+	y: 220752e3
+};
+function parseHumanDuration(s) {
+	const unitsMap = new Map(Object.entries(units));
+	s = s.trim().toLowerCase();
+	let base = 1;
+	for (const [name, _] of unitsMap) if (s.endsWith(name)) {
+		s = s.substring(0, s.length - name.length);
+		base = unitsMap.get(name) || 1;
+		break;
+	}
+	return Number(s) * base;
+}
+__name(parseHumanDuration, "parseHumanDuration");
+function parseNonHyphenedUuid(uuid) {
+	if (uuid == null || uuid.includes("-")) return uuid;
+	if (uuid.length != 32) return null;
+	const uuid_parts = [];
+	uuid_parts.push(uuid.slice(0, 8));
+	uuid_parts.push(uuid.slice(8, 12));
+	uuid_parts.push(uuid.slice(12, 16));
+	uuid_parts.push(uuid.slice(16, 20));
+	uuid_parts.push(uuid.slice(20));
+	let hyphenated = "";
+	uuid_parts.forEach((part) => hyphenated += part + "-");
+	return hyphenated.slice(0, 36);
+}
+__name(parseNonHyphenedUuid, "parseNonHyphenedUuid");
+function parseByteSize(s, base = void 0) {
+	const match = s.match(/^(\d*\.*\d*)\s*([kKmMgGtTpP]{0,1})([i]{0,1}[bB]{0,1})$/);
+	if (!match) return NaN;
+	const size = match[1];
+	if (size.length === 0 || isNaN(Number(size))) return NaN;
+	const unit = match[2].toLowerCase();
+	const sizeUnits = {
+		k: 1,
+		m: 2,
+		g: 3,
+		t: 4,
+		p: 5
+	};
+	if (unit.length !== 0 && !(unit in sizeUnits)) return NaN;
+	const binary = match[3].toLowerCase() == "ib";
+	if (binary && unit.length === 0) return NaN;
+	const pow = sizeUnits[unit] || 0;
+	return Math.floor(Number(size) * Math.pow(base ?? (binary ? 1024 : 1e3), pow));
+}
+__name(parseByteSize, "parseByteSize");
+var UNSUPPORTED_BOMS = [
+	{
+		buffer: Buffer.from([
+			0,
+			0,
+			254,
+			255
+		]),
+		encoding: "UTF-32 BE"
+	},
+	{
+		buffer: Buffer.from([
+			255,
+			254,
+			0,
+			0
+		]),
+		encoding: "UTF-32 LE"
+	},
+	{
+		buffer: Buffer.from([254, 255]),
+		encoding: "UTF-16 BE"
+	},
+	{
+		buffer: Buffer.from([255, 254]),
+		encoding: "UTF-16 LE"
+	}
+];
+function removeBOMAndValidate(buffer, file2) {
+	for (const bom of UNSUPPORTED_BOMS) if (buffer.length >= bom.buffer.length && buffer.subarray(0, bom.buffer.length).equals(bom.buffer)) throw new ParseError({
+		text: `Configuration file contains ${bom.encoding} byte order marker`,
+		notes: [{ text: `The file "${file2}" appears to be encoded as ${bom.encoding}. Please save the file as UTF-8 without BOM.` }],
+		location: {
+			file: file2,
+			line: 1,
+			column: 0
+		},
+		telemetryMessage: `${bom.encoding} BOM detected`
+	});
+	const content = buffer.toString("utf-8");
+	if (content.charCodeAt(0) === 65279) return content.slice(1);
+	return content;
+}
+__name(removeBOMAndValidate, "removeBOMAndValidate");
+var INHERIT_SYMBOL = Symbol.for("inherit_binding");
+var PATH_TO_DEPLOY_CONFIG = ".wrangler/deploy/config.json";
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+__name(absolute, "absolute");
+function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
+	}
+	return arr;
+}
+__name(up, "up");
+function file(name, options) {
+	let dir, tmp;
+	for (dir of up(options && options.cwd || "", options)) try {
+		tmp = join(dir, name);
+		if (statSync(tmp).isFile()) return tmp;
+	} catch {}
+}
+__name(file, "file");
+function dedent$2(templ) {
+	var values = [];
+	for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+	var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+	strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+	var indentLengths = strings.reduce(function(arr, str) {
+		var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+		if (matches) return arr.concat(matches.map(function(match) {
+			var _a, _b;
+			return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+		}));
+		return arr;
+	}, []);
+	if (indentLengths.length) {
+		var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+		strings = strings.map(function(str) {
+			return str.replace(pattern_1, "\n");
+		});
+	}
+	strings[0] = strings[0].replace(/^\r?\n/, "");
+	var string = strings[0];
+	values.forEach(function(value, i) {
+		var endentations = string.match(/(?:^|\n)( *)$/);
+		var endentation = endentations ? endentations[1] : "";
+		var indentedValue = value;
+		if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i2) {
+			return i2 === 0 ? str : "" + endentation + str;
+		}).join("\n");
+		string += indentedValue + strings[i + 1];
+	});
+	return string;
+}
+__name(dedent$2, "dedent");
+var esm_default = dedent$2;
+function resolveWranglerConfigPath({ config, script }, options) {
+	if (config !== void 0) return {
+		userConfigPath: config,
+		configPath: config,
+		deployConfigPath: void 0,
+		redirected: false
+	};
+	return findWranglerConfig(script !== void 0 ? path2.dirname(script) : process.cwd(), options);
+}
+__name(resolveWranglerConfigPath, "resolveWranglerConfigPath");
+function findWranglerConfig(referencePath = process.cwd(), { useRedirectIfAvailable = false } = {}) {
+	const userConfigPath = file(`wrangler.json`, { cwd: referencePath }) ?? file(`wrangler.jsonc`, { cwd: referencePath }) ?? file(`wrangler.toml`, { cwd: referencePath });
+	if (!useRedirectIfAvailable) return {
+		userConfigPath,
+		configPath: userConfigPath,
+		deployConfigPath: void 0,
+		redirected: false
+	};
+	const { configPath, deployConfigPath, redirected } = findRedirectedWranglerConfig(referencePath, userConfigPath);
+	return {
+		userConfigPath,
+		configPath,
+		deployConfigPath,
+		redirected
+	};
+}
+__name(findWranglerConfig, "findWranglerConfig");
+function findRedirectedWranglerConfig(cwd, userConfigPath) {
+	const deployConfigPath = file(PATH_TO_DEPLOY_CONFIG, { cwd });
+	if (deployConfigPath === void 0) return {
+		configPath: userConfigPath,
+		deployConfigPath,
+		redirected: false
+	};
+	let redirectedConfigPath;
+	const deployConfigFile = readFileSync$1(deployConfigPath);
+	try {
+		const deployConfig = parseJSONC(deployConfigFile, deployConfigPath);
+		redirectedConfigPath = deployConfig.configPath && path2.resolve(path2.dirname(deployConfigPath), deployConfig.configPath);
+	} catch (e) {
+		throw new UserError(`Failed to parse the deploy configuration file at ${path2.relative(".", deployConfigPath)}`, {
+			cause: e,
+			telemetryMessage: false
+		});
+	}
+	if (!redirectedConfigPath) throw new UserError(esm_default`
+			A deploy configuration file was found at "${path2.relative(".", deployConfigPath)}".
+			But this is not valid - the required "configPath" property was not found.
+			Instead this file contains:
+			\`\`\`
+			${deployConfigFile}
+			\`\`\`
+		`, { telemetryMessage: false });
+	if (!existsSync(redirectedConfigPath)) throw new UserError(esm_default`
+				There is a deploy configuration at "${path2.relative(".", deployConfigPath)}".
+				But the redirected configuration path it points to, "${path2.relative(".", redirectedConfigPath)}", does not exist.
+			`, { telemetryMessage: false });
+	if (userConfigPath) {
+		if (path2.join(path2.dirname(userConfigPath), PATH_TO_DEPLOY_CONFIG) !== deployConfigPath) throw new UserError(esm_default`
+					Found both a user configuration file at "${path2.relative(".", userConfigPath)}"
+					and a deploy configuration file at "${path2.relative(".", deployConfigPath)}".
+					But these do not share the same base path so it is not clear which should be used.
+				`, { telemetryMessage: false });
+	}
+	return {
+		configPath: redirectedConfigPath,
+		deployConfigPath,
+		redirected: true
+	};
+}
+__name(findRedirectedWranglerConfig, "findRedirectedWranglerConfig");
+function isRedirectedConfig(config) {
+	return config.configPath !== void 0 && config.configPath !== config.userConfigPath;
+}
+__name(isRedirectedConfig, "isRedirectedConfig");
+function isRedirectedRawConfig(rawConfig, configPath, userConfigPath) {
+	return isRedirectedConfig({
+		configPath,
+		userConfigPath
+	});
+}
+__name(isRedirectedRawConfig, "isRedirectedRawConfig");
+function configFormat(configPath) {
+	if (configPath?.endsWith("toml")) return "toml";
+	if (configPath?.endsWith("jsonc")) return "jsonc";
+	if (configPath?.endsWith("json")) return "json";
+	return "none";
+}
+__name(configFormat, "configFormat");
+function configFileName(configPath) {
+	switch (configFormat(configPath)) {
+		case "toml": return "wrangler.toml";
+		case "json": return "wrangler.json";
+		case "jsonc": return "wrangler.jsonc";
+		default: return "Wrangler configuration";
+	}
+}
+__name(configFileName, "configFileName");
+function formatConfigSnippet(snippet, configPath, formatted = true) {
+	if (configFormat(configPath) === "toml") return dist_default.stringify(snippet);
+	else return formatted ? JSON.stringify(snippet, null, 2) : JSON.stringify(snippet);
+}
+__name(formatConfigSnippet, "formatConfigSnippet");
+
+//#endregion
+//#region src/build-output.ts
+/**
+* Initial draft version of the Build Output API.
+*
+* Will move to `v1` when the spec stabilises.
+*/
+const BUILD_OUTPUT_VERSION = "v0";
+/**
+* Project-relative root.
+*/
+const BUILD_OUTPUT_ROOT = ".cloudflare/output";
+/**
+* Filename of the per-Worker config.
+*/
+const WORKER_CONFIG_FILENAME = "worker.config.json";
+/**
+* Absolute path to the Build Output API root for the current project.
+*/
+function getBuildOutputDir(root) {
+	return path.resolve(root, BUILD_OUTPUT_ROOT);
+}
+/**
+* Clean the build output directory.
+*/
+async function cleanBuildOutputDir(root) {
+	await removeDir(getBuildOutputDir(root));
+}
+/**
+* Absolute path to the Workers output directory.
+*/
+function getWorkersDir(root) {
+	return path.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, "workers");
+}
+/**
+* Absolute path to the config file for a given Worker.
+*/
+function getWorkerConfigPath(root, workerName) {
+	return path.join(getWorkersDir(root), workerName, WORKER_CONFIG_FILENAME);
+}
+/**
+* Absolute path to the bundle directory for a given Worker.
+*/
+function getWorkerBundleDir(root, workerName) {
+	return path.join(getWorkersDir(root), workerName, "bundle");
+}
+/**
+* Absolute path to the assets directory for a given Worker.
+*/
+function getWorkerAssetsDir(root, workerName) {
+	return path.join(getWorkersDir(root), workerName, "assets");
+}
+/**
+* Write the output `worker.config.json` for a given Worker to the Build
+* Output API tree.
+*
+* - Workers mode: `manifest` is provided (bundle/ present on disk).
+* - Assets-only mode: `manifest` is omitted (no bundle/ directory).
+*/
+async function writeOutputWorkerConfig(root, parsedConfig, manifest) {
+	const { entrypoint: _entrypoint,...rest } = parsedConfig;
+	const outputConfig = {
+		...rest,
+		manifest
+	};
+	const workerOutputDir = path.join(getWorkersDir(root), outputConfig.name);
+	await fsp.mkdir(workerOutputDir, { recursive: true });
+	const configPath = getWorkerConfigPath(root, outputConfig.name);
+	await fsp.writeFile(configPath, JSON.stringify(outputConfig));
+}
+
+//#endregion
+//#region src/schema.ts
+const AssetsSchema = z.strictObject({
+	htmlHandling: z.enum([
+		"auto-trailing-slash",
+		"drop-trailing-slash",
+		"force-trailing-slash",
+		"none"
+	]).optional(),
+	notFoundHandling: z.enum([
+		"single-page-application",
+		"404-page",
+		"none"
+	]).optional(),
+	runWorkerFirst: z.union([z.array(z.string()), z.boolean()]).optional()
+});
+const KnownBindingSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("agent-memory"),
+		namespace: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("ai"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("ai-search"),
+		name: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("ai-search-namespace"),
+		namespace: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("analytics-engine-dataset"),
+		name: z.string().optional()
+	}),
+	z.strictObject({
+		type: z.literal("artifacts"),
+		namespace: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({ type: z.literal("assets") }),
+	z.strictObject({
+		type: z.literal("browser"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("d1"),
+		name: z.string().optional(),
+		id: z.string().optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("dispatch-namespace"),
+		namespace: z.string(),
+		outbound: z.strictObject({
+			workerName: z.string(),
+			parameters: z.array(z.string()).optional()
+		}).optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("durable-object"),
+		workerName: z.string(),
+		exportName: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("flagship"),
+		id: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("hyperdrive"),
+		id: z.string(),
+		localConnectionString: z.string().optional()
+	}),
+	z.strictObject({
+		type: z.literal("images"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("json"),
+		value: z.json()
+	}),
+	z.strictObject({
+		type: z.literal("kv"),
+		id: z.string().optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("logfwdr"),
+		destination: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("media"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("mtls-certificate"),
+		id: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("pipeline"),
+		name: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("queue"),
+		name: z.string(),
+		deliveryDelay: z.number().optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("rate-limit"),
+		namespace: z.string(),
+		simple: z.strictObject({
+			limit: z.number(),
+			period: z.union([z.literal(10), z.literal(60)])
+		})
+	}),
+	z.strictObject({
+		type: z.literal("r2"),
+		name: z.string().optional(),
+		jurisdiction: z.string().optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({ type: z.literal("secret") }),
+	z.strictObject({
+		type: z.literal("secrets-store-secret"),
+		storeId: z.string(),
+		secretName: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("send-email"),
+		destinationAddress: z.string().optional(),
+		allowedDestinationAddresses: z.array(z.string()).optional(),
+		allowedSenderAddresses: z.array(z.string()).optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("stream"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("text"),
+		value: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("vectorize"),
+		name: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({ type: z.literal("version-metadata") }),
+	z.strictObject({
+		type: z.literal("vpc-service"),
+		id: z.string(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("vpc-network"),
+		tunnelId: z.string().optional(),
+		networkId: z.string().optional(),
+		remote: z.boolean().optional()
+	}).superRefine((value, ctx) => {
+		const hasTunnel = value.tunnelId !== void 0;
+		if (hasTunnel === (value.networkId !== void 0)) ctx.addIssue({
+			code: "custom",
+			message: hasTunnel ? `"vpc-network" bindings must specify exactly one of "tunnelId" or "networkId", not both` : `"vpc-network" bindings must specify either "tunnelId" or "networkId"`
+		});
+	}),
+	z.strictObject({
+		type: z.literal("web-search"),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({
+		type: z.literal("worker"),
+		workerName: z.string(),
+		exportName: z.string().optional(),
+		props: z.record(z.string(), z.unknown()).optional(),
+		remote: z.boolean().optional()
+	}),
+	z.strictObject({ type: z.literal("worker-loader") })
+]);
+const UnsafeBindingSchema = z.looseObject({
+	type: z.templateLiteral(["unsafe:", z.string().min(1)]),
+	dev: z.strictObject({
+		plugin: z.strictObject({
+			package: z.string(),
+			name: z.string()
+		}),
+		options: z.record(z.string(), z.unknown()).optional()
+	}).optional()
+});
+const BindingSchema = z.unknown().transform((value, ctx) => {
+	const result = (typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && value.type.startsWith("unsafe:") ? UnsafeBindingSchema : KnownBindingSchema).safeParse(value);
+	if (!result.success) {
+		ctx.issues.push(...result.error.issues);
+		return z.NEVER;
+	}
+	return result.data;
+});
+function isParsedUnsafeBinding(binding) {
+	return binding.type.startsWith("unsafe:");
+}
+const CacheSchema = z.strictObject({
+	enabled: z.boolean(),
+	crossVersionCache: z.boolean().optional()
+});
+/**
+* Binding types that can only be defined once per worker.
+*/
+const SINGLETON_BINDING_TYPES = new Set([
+	"ai",
+	"assets",
+	"browser",
+	"images",
+	"media",
+	"stream",
+	"version-metadata",
+	"web-search"
+]);
+const listFormatter = new Intl.ListFormat("en-US");
+const EnvSchema = z.record(z.string(), BindingSchema).superRefine((env, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	for (const binding of Object.values(env)) {
+		const type = binding.type;
+		if (SINGLETON_BINDING_TYPES.has(type)) {
+			if (seen.has(type)) duplicates.add(type);
+			seen.add(type);
+		}
+	}
+	if (duplicates.size > 0) ctx.addIssue({
+		code: "custom",
+		message: `${listFormatter.format([...duplicates].sort())} bindings can only be defined once`
+	});
+}).optional();
+const ExportSchema = z.union([
+	z.strictObject({
+		type: z.literal("durable-object"),
+		state: z.literal("created").optional(),
+		storage: z.enum(["sqlite", "legacy-kv"])
+	}),
+	z.strictObject({
+		type: z.literal("durable-object"),
+		state: z.literal("deleted")
+	}),
+	z.strictObject({
+		type: z.literal("durable-object"),
+		state: z.literal("renamed"),
+		renamedTo: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("durable-object"),
+		state: z.literal("transferred"),
+		transferredTo: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("durable-object"),
+		state: z.literal("expecting-transfer"),
+		storage: z.enum(["sqlite", "legacy-kv"]),
+		transferFrom: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("worker"),
+		cache: z.strictObject({ enabled: z.boolean() }).optional()
+	})
+]);
+const LimitsSchema = z.strictObject({
+	cpuMs: z.number().optional(),
+	subrequests: z.number().optional()
+});
+const ObservabilitySchema = z.strictObject({
+	enabled: z.boolean().optional(),
+	headSamplingRate: z.number().optional(),
+	logs: z.strictObject({
+		enabled: z.boolean().optional(),
+		headSamplingRate: z.number().optional(),
+		invocationLogs: z.boolean().optional(),
+		persist: z.boolean().optional(),
+		destinations: z.array(z.string()).optional()
+	}).optional(),
+	traces: z.strictObject({
+		enabled: z.boolean().optional(),
+		headSamplingRate: z.number().optional(),
+		persist: z.boolean().optional(),
+		destinations: z.array(z.string()).optional()
+	}).optional()
+});
+const PlacementSchema = z.union([
+	z.strictObject({
+		mode: z.enum(["off", "smart"]),
+		hint: z.string().optional()
+	}),
+	z.strictObject({
+		mode: z.literal("targeted").optional(),
+		region: z.string()
+	}),
+	z.strictObject({
+		mode: z.literal("targeted").optional(),
+		host: z.string()
+	}),
+	z.strictObject({
+		mode: z.literal("targeted").optional(),
+		hostname: z.string()
+	})
+]);
+const TailConsumerSchema = z.strictObject({
+	workerName: z.string(),
+	streaming: z.boolean().optional()
+});
+const TriggerSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("fetch"),
+		pattern: z.string(),
+		zone: z.string().optional()
+	}),
+	z.strictObject({
+		type: z.literal("queue"),
+		name: z.string(),
+		deadLetterQueue: z.string().optional(),
+		maxBatchSize: z.number().optional(),
+		maxBatchTimeout: z.number().optional(),
+		maxConcurrency: z.number().nullable().optional(),
+		maxRetries: z.number().optional(),
+		retryDelay: z.number().optional(),
+		visibilityTimeoutMs: z.number().optional()
+	}),
+	z.strictObject({
+		type: z.literal("scheduled"),
+		schedule: z.string()
+	})
+]);
+const UnsafeSchema = z.strictObject({
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	capnp: z.union([z.strictObject({
+		basePath: z.string(),
+		sourceSchemas: z.array(z.string()),
+		compiledSchema: z.never().optional()
+	}), z.strictObject({
+		basePath: z.never().optional(),
+		sourceSchemas: z.never().optional(),
+		compiledSchema: z.string()
+	})]).optional()
+});
+/**
+* Base Worker schema — the set of fields shared between the input
+* (user-authored) and output (on-disk) Worker configs.
+*/
+const BaseWorkerSchema = z.strictObject({
+	name: z.string(),
+	accountId: z.string().optional(),
+	compatibilityDate: z.string(),
+	compatibilityFlags: z.array(z.string()).optional(),
+	assets: AssetsSchema.optional(),
+	domains: z.array(z.string()).optional(),
+	triggers: z.array(TriggerSchema).optional(),
+	tailConsumers: z.array(TailConsumerSchema).optional(),
+	cache: CacheSchema.optional(),
+	placement: PlacementSchema.optional(),
+	limits: LimitsSchema.optional(),
+	logpush: z.boolean().optional(),
+	observability: ObservabilitySchema.optional(),
+	workersDev: z.boolean().optional(),
+	previewUrls: z.boolean().optional(),
+	complianceRegion: z.enum(["public", "fedramp-high"]).optional(),
+	firstPartyWorker: z.boolean().optional(),
+	unsafe: UnsafeSchema.optional(),
+	env: EnvSchema,
+	exports: z.record(z.string(), ExportSchema).optional()
+});
+/**
+* Input Worker schema — the shape that user-authored `cloudflare.config.ts`
+* files are validated against. Adds an optional `entrypoint` field to the
+* base schema.
+*/
+const InputWorkerSchema = BaseWorkerSchema.extend({ entrypoint: z.union([z.string(), z.strictObject({ default: z.string() })]).transform((value) => typeof value === "string" ? value : value.default).optional() });
+const ModuleTypeSchema = z.enum([
+	"esm",
+	"cjs",
+	"python",
+	"python-requirement",
+	"wasm",
+	"text",
+	"data",
+	"json",
+	"sourcemap"
+]);
+const ManifestSchema = z.strictObject({
+	mainModule: z.string(),
+	modules: z.record(z.string(), z.strictObject({ type: ModuleTypeSchema }))
+});
+/**
+* Output Worker schema — the shape of `worker.config.json` in the
+* Build Output API. Adds an optional `manifest` field to the
+* base schema.
+*/
+const OutputWorkerSchema = BaseWorkerSchema.extend({ manifest: ManifestSchema.optional() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/dist/index.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dedent = void 0;
+	function dedent$1(templ) {
+		var values = [];
+		for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+		var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+		strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+		var indentLengths = strings.reduce(function(arr, str) {
+			var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+			if (matches) return arr.concat(matches.map(function(match) {
+				var _a, _b;
+				return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+			}));
+			return arr;
+		}, []);
+		if (indentLengths.length) {
+			var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+			strings = strings.map(function(str) {
+				return str.replace(pattern_1, "\n");
+			});
+		}
+		strings[0] = strings[0].replace(/^\r?\n/, "");
+		var string = strings[0];
+		values.forEach(function(value, i) {
+			var endentations = string.match(/(?:^|\n)( *)$/);
+			var endentation = endentations ? endentations[1] : "";
+			var indentedValue = value;
+			if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i$1) {
+				return i$1 === 0 ? str : "" + endentation + str;
+			}).join("\n");
+			string += indentedValue + strings[i + 1];
+		});
+		return string;
+	}
+	exports.dedent = dedent$1;
+}) });
+
+//#endregion
+//#region src/generate.ts
+var import_dist = require_dist();
+/**
+* Generate the content for worker-configuration.d.ts
+*
+* @example
+* ```typescript
+* import { generateTypes } from "@cloudflare/config";
+* import { writeFileSync } from "node:fs";
+*
+* const content = generateTypes({
+*   configPath: "./cloudflare.config.ts",
+* });
+*
+* writeFileSync("worker-configuration.d.ts", content);
+* ```
+*/
+function generateTypes({ configPath, packageName = "@cloudflare/config" }) {
+	return import_dist.dedent`
+		/* eslint-disable */
+		// Generated by @cloudflare/config
+		type __WorkerConfig = import("${packageName}").UnwrapConfig<typeof import("${configPath.replace(/\.(ts|js|mts|mjs)$/, "")}").default>;
+		type __Env = import("${packageName}").InferEnv<__WorkerConfig>;
+
+		declare namespace Cloudflare {
+			interface GlobalProps {
+				mainModule: import("${packageName}").InferMainModule<__WorkerConfig>;
+				durableNamespaces: import("${packageName}").InferDurableNamespaces<__WorkerConfig>;
+			}
+			interface Env extends __Env {}
+		}
+		interface Env extends Cloudflare.Env {}
+
+	`;
+}
+
+//#endregion
+//#region src/convert.ts
+/**
+* Convert a parsed `@cloudflare/config` config into a Wrangler `RawConfig`.
+*
+* The caller is responsible for unwrapping any function/promise wrapper around
+* the config and validating it against `InputWorkerSchema` before passing it in.
+*
+* @param config The parsed (post-validation) config.
+* @returns The corresponding Wrangler `RawConfig`.
+*/
+function convertToWranglerConfig(config) {
+	const result = {};
+	convertTopLevel(config, result);
+	convertBindingsAndAssets(config, result);
+	convertExports(config, result);
+	convertDomains(config, result);
+	convertTriggers(config, result);
+	convertTailConsumers(config, result);
+	return result;
+}
+function convertTopLevel(config, result) {
+	if (config.name !== void 0) result.name = config.name;
+	if (typeof config.entrypoint === "string") result.main = config.entrypoint;
+	if (config.accountId !== void 0) result.account_id = config.accountId;
+	if (config.compatibilityDate !== void 0) result.compatibility_date = config.compatibilityDate;
+	if (config.compatibilityFlags !== void 0) result.compatibility_flags = config.compatibilityFlags;
+	if (config.workersDev !== void 0) result.workers_dev = config.workersDev;
+	if (config.previewUrls !== void 0) result.preview_urls = config.previewUrls;
+	if (config.logpush !== void 0) result.logpush = config.logpush;
+	if (config.complianceRegion !== void 0) result.compliance_region = config.complianceRegion === "fedramp-high" ? "fedramp_high" : "public";
+	if (config.firstPartyWorker !== void 0) result.first_party_worker = config.firstPartyWorker;
+	if (config.placement !== void 0) result.placement = config.placement;
+	if (config.limits !== void 0) {
+		const limits = {};
+		if (config.limits.cpuMs !== void 0) limits.cpu_ms = config.limits.cpuMs;
+		if (config.limits.subrequests !== void 0) limits.subrequests = config.limits.subrequests;
+		result.limits = limits;
+	}
+	if (config.observability !== void 0) result.observability = convertObservability(config.observability);
+	if (config.cache !== void 0) {
+		const cache = { enabled: config.cache.enabled };
+		if (config.cache.crossVersionCache !== void 0) cache.cross_version_cache = config.cache.crossVersionCache;
+		result.cache = cache;
+	}
+	if (config.unsafe !== void 0) result.unsafe = convertUnsafeTopLevel(config.unsafe);
+}
+function convertObservability(observability) {
+	const out = {};
+	if (observability.enabled !== void 0) out.enabled = observability.enabled;
+	if (observability.headSamplingRate !== void 0) out.head_sampling_rate = observability.headSamplingRate;
+	if (observability.logs !== void 0) {
+		const logs = {};
+		const { logs: src } = observability;
+		if (src.enabled !== void 0) logs.enabled = src.enabled;
+		if (src.headSamplingRate !== void 0) logs.head_sampling_rate = src.headSamplingRate;
+		if (src.invocationLogs !== void 0) logs.invocation_logs = src.invocationLogs;
+		if (src.persist !== void 0) logs.persist = src.persist;
+		if (src.destinations !== void 0) logs.destinations = src.destinations;
+		out.logs = logs;
+	}
+	if (observability.traces !== void 0) {
+		const traces = {};
+		const { traces: src } = observability;
+		if (src.enabled !== void 0) traces.enabled = src.enabled;
+		if (src.headSamplingRate !== void 0) traces.head_sampling_rate = src.headSamplingRate;
+		if (src.persist !== void 0) traces.persist = src.persist;
+		if (src.destinations !== void 0) traces.destinations = src.destinations;
+		out.traces = traces;
+	}
+	return out;
+}
+function convertUnsafeTopLevel(unsafe) {
+	const out = {};
+	if (unsafe.metadata !== void 0) out.metadata = unsafe.metadata;
+	if (unsafe.capnp !== void 0) {
+		if ("compiledSchema" in unsafe.capnp && unsafe.capnp.compiledSchema) out.capnp = { compiled_schema: unsafe.capnp.compiledSchema };
+		else if ("basePath" in unsafe.capnp && unsafe.capnp.basePath) out.capnp = {
+			base_path: unsafe.capnp.basePath,
+			source_schemas: unsafe.capnp.sourceSchemas ?? []
+		};
+	}
+	return out;
+}
+function convertBindingsAndAssets(config, result) {
+	let assetsBindingName;
+	const env = config.env ?? {};
+	const kvNamespaces = [];
+	const d1Databases = [];
+	const r2Buckets = [];
+	const vectorize = [];
+	const mtlsCertificates = [];
+	const hyperdrive = [];
+	const pipelines = [];
+	const flagship = [];
+	const aiSearch = [];
+	const aiSearchNamespaces = [];
+	const agentMemory = [];
+	const analyticsEngineDatasets = [];
+	const artifacts = [];
+	const dispatchNamespaces = [];
+	const secretsStoreSecrets = [];
+	const sendEmail = [];
+	const vpcServices = [];
+	const vpcNetworks = [];
+	const workerLoaders = [];
+	const ratelimits = [];
+	const services = [];
+	const durableObjectBindings = [];
+	const workflows = [];
+	const queueProducers = [];
+	const logfwdrBindings = [];
+	const unsafeBindings = [];
+	const vars = {};
+	const secretsRequired = [];
+	for (const [name, binding] of Object.entries(env)) {
+		if (isParsedUnsafeBinding(binding)) {
+			unsafeBindings.push({
+				...binding,
+				name,
+				type: binding.type.slice(7)
+			});
+			continue;
+		}
+		switch (binding.type) {
+			case "agent-memory":
+				agentMemory.push(omitUndefined({
+					binding: name,
+					namespace: binding.namespace,
+					remote: binding.remote
+				}));
+				break;
+			case "ai":
+				result.ai = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "ai-search":
+				aiSearch.push(omitUndefined({
+					binding: name,
+					instance_name: binding.name,
+					remote: binding.remote
+				}));
+				break;
+			case "ai-search-namespace":
+				aiSearchNamespaces.push(omitUndefined({
+					binding: name,
+					namespace: binding.namespace,
+					remote: binding.remote
+				}));
+				break;
+			case "analytics-engine-dataset":
+				analyticsEngineDatasets.push(omitUndefined({
+					binding: name,
+					dataset: binding.name
+				}));
+				break;
+			case "artifacts":
+				artifacts.push(omitUndefined({
+					binding: name,
+					namespace: binding.namespace,
+					remote: binding.remote
+				}));
+				break;
+			case "assets":
+				assetsBindingName = name;
+				break;
+			case "browser":
+				result.browser = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "d1":
+				d1Databases.push(omitUndefined({
+					binding: name,
+					database_id: binding.id,
+					database_name: binding.name,
+					remote: binding.remote
+				}));
+				break;
+			case "dispatch-namespace": {
+				const entry = {
+					binding: name,
+					namespace: binding.namespace
+				};
+				if (binding.outbound) entry.outbound = omitUndefined({
+					service: binding.outbound.workerName,
+					parameters: binding.outbound.parameters
+				});
+				if (binding.remote !== void 0) entry.remote = binding.remote;
+				dispatchNamespaces.push(entry);
+				break;
+			}
+			case "durable-object":
+				durableObjectBindings.push({
+					name,
+					class_name: binding.exportName,
+					script_name: binding.workerName
+				});
+				break;
+			case "flagship":
+				flagship.push(omitUndefined({
+					binding: name,
+					app_id: binding.id,
+					remote: binding.remote
+				}));
+				break;
+			case "hyperdrive":
+				hyperdrive.push(omitUndefined({
+					binding: name,
+					id: binding.id,
+					localConnectionString: binding.localConnectionString
+				}));
+				break;
+			case "images":
+				result.images = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "json":
+				vars[name] = binding.value;
+				break;
+			case "kv":
+				kvNamespaces.push(omitUndefined({
+					binding: name,
+					id: binding.id,
+					remote: binding.remote
+				}));
+				break;
+			case "logfwdr":
+				logfwdrBindings.push({
+					name,
+					destination: binding.destination
+				});
+				break;
+			case "media":
+				result.media = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "mtls-certificate":
+				mtlsCertificates.push(omitUndefined({
+					binding: name,
+					certificate_id: binding.id,
+					remote: binding.remote
+				}));
+				break;
+			case "pipeline":
+				pipelines.push(omitUndefined({
+					binding: name,
+					stream: binding.name,
+					remote: binding.remote
+				}));
+				break;
+			case "queue":
+				queueProducers.push(omitUndefined({
+					binding: name,
+					queue: binding.name,
+					delivery_delay: binding.deliveryDelay,
+					remote: binding.remote
+				}));
+				break;
+			case "rate-limit":
+				ratelimits.push({
+					name,
+					namespace_id: binding.namespace,
+					simple: binding.simple
+				});
+				break;
+			case "r2":
+				r2Buckets.push(omitUndefined({
+					binding: name,
+					bucket_name: binding.name,
+					jurisdiction: binding.jurisdiction,
+					remote: binding.remote
+				}));
+				break;
+			case "secret":
+				secretsRequired.push(name);
+				break;
+			case "secrets-store-secret":
+				secretsStoreSecrets.push({
+					binding: name,
+					store_id: binding.storeId,
+					secret_name: binding.secretName
+				});
+				break;
+			case "send-email":
+				sendEmail.push(omitUndefined({
+					name,
+					destination_address: binding.destinationAddress,
+					allowed_destination_addresses: binding.allowedDestinationAddresses,
+					allowed_sender_addresses: binding.allowedSenderAddresses,
+					remote: binding.remote
+				}));
+				break;
+			case "stream":
+				result.stream = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "text":
+				vars[name] = binding.value;
+				break;
+			case "vectorize":
+				vectorize.push(omitUndefined({
+					binding: name,
+					index_name: binding.name,
+					remote: binding.remote
+				}));
+				break;
+			case "version-metadata":
+				result.version_metadata = { binding: name };
+				break;
+			case "vpc-service":
+				vpcServices.push(omitUndefined({
+					binding: name,
+					service_id: binding.id,
+					remote: binding.remote
+				}));
+				break;
+			case "vpc-network":
+				if (binding.tunnelId !== void 0) vpcNetworks.push(omitUndefined({
+					binding: name,
+					tunnel_id: binding.tunnelId,
+					remote: binding.remote
+				}));
+				else if (binding.networkId !== void 0) vpcNetworks.push(omitUndefined({
+					binding: name,
+					network_id: binding.networkId,
+					remote: binding.remote
+				}));
+				break;
+			case "web-search":
+				result.websearch = omitUndefined({
+					binding: name,
+					remote: binding.remote
+				});
+				break;
+			case "worker":
+				services.push(omitUndefined({
+					binding: name,
+					service: binding.workerName,
+					entrypoint: binding.exportName,
+					props: binding.props,
+					remote: binding.remote
+				}));
+				break;
+			case "worker-loader":
+				workerLoaders.push({ binding: name });
+				break;
+		}
+	}
+	if (kvNamespaces.length) result.kv_namespaces = kvNamespaces;
+	if (d1Databases.length) result.d1_databases = d1Databases;
+	if (r2Buckets.length) result.r2_buckets = r2Buckets;
+	if (vectorize.length) result.vectorize = vectorize;
+	if (mtlsCertificates.length) result.mtls_certificates = mtlsCertificates;
+	if (hyperdrive.length) result.hyperdrive = hyperdrive;
+	if (pipelines.length) result.pipelines = pipelines;
+	if (flagship.length) result.flagship = flagship;
+	if (aiSearch.length) result.ai_search = aiSearch;
+	if (aiSearchNamespaces.length) result.ai_search_namespaces = aiSearchNamespaces;
+	if (agentMemory.length) result.agent_memory = agentMemory;
+	if (analyticsEngineDatasets.length) result.analytics_engine_datasets = analyticsEngineDatasets;
+	if (artifacts.length) result.artifacts = artifacts;
+	if (dispatchNamespaces.length) result.dispatch_namespaces = dispatchNamespaces;
+	if (secretsStoreSecrets.length) result.secrets_store_secrets = secretsStoreSecrets;
+	if (sendEmail.length) result.send_email = sendEmail;
+	if (vpcServices.length) result.vpc_services = vpcServices;
+	if (vpcNetworks.length) result.vpc_networks = vpcNetworks;
+	if (workerLoaders.length) result.worker_loaders = workerLoaders;
+	if (ratelimits.length) result.ratelimits = ratelimits;
+	if (services.length) result.services = services;
+	if (durableObjectBindings.length) result.durable_objects = { bindings: durableObjectBindings };
+	if (workflows.length) result.workflows = workflows;
+	if (queueProducers.length) result.queues = {
+		...result.queues ?? {},
+		producers: queueProducers
+	};
+	if (logfwdrBindings.length) result.logfwdr = { bindings: logfwdrBindings };
+	if (unsafeBindings.length) result.unsafe = {
+		...result.unsafe ?? {},
+		bindings: unsafeBindings
+	};
+	if (Object.keys(vars).length) result.vars = vars;
+	if (secretsRequired.length) result.secrets = { required: secretsRequired };
+	if (config.assets !== void 0 || assetsBindingName !== void 0) {
+		const assets = {};
+		if (assetsBindingName !== void 0) assets.binding = assetsBindingName;
+		if (config.assets?.htmlHandling !== void 0) assets.html_handling = config.assets.htmlHandling;
+		if (config.assets?.notFoundHandling !== void 0) assets.not_found_handling = config.assets.notFoundHandling;
+		if (config.assets?.runWorkerFirst !== void 0) assets.run_worker_first = config.assets.runWorkerFirst;
+		result.assets = assets;
+	}
+}
+function convertExports(config, result) {
+	const exports$2 = config.exports;
+	if (!exports$2) return;
+	const converted = {};
+	const unknownExports = {};
+	for (const [exportName, value] of Object.entries(exports$2)) {
+		if (value.type === "worker") {
+			converted[exportName] = value;
+			continue;
+		}
+		if (value.type !== "durable-object") {
+			unknownExports[exportName] = value;
+			continue;
+		}
+		switch (value.state) {
+			case void 0:
+			case "created":
+				converted[exportName] = {
+					type: "durable-object",
+					storage: value.storage
+				};
+				break;
+			case "deleted":
+				converted[exportName] = {
+					type: "durable-object",
+					state: "deleted"
+				};
+				break;
+			case "renamed":
+				converted[exportName] = {
+					type: "durable-object",
+					state: "renamed",
+					renamed_to: value.renamedTo
+				};
+				break;
+			case "transferred":
+				converted[exportName] = {
+					type: "durable-object",
+					state: "transferred",
+					transferred_to: value.transferredTo
+				};
+				break;
+			case "expecting-transfer":
+				converted[exportName] = {
+					type: "durable-object",
+					state: "expecting-transfer",
+					storage: value.storage,
+					transfer_from: value.transferFrom
+				};
+				break;
+		}
+	}
+	if (Object.keys(unknownExports).length > 0) throw new UserError("Unknown export types found: " + Object.entries(unknownExports).map(([exportName, { type }]) => `- ${exportName} : ${type}`).join("\n"), { telemetryMessage: "Unknown export types found" });
+	if (Object.keys(converted).length > 0) result.exports = converted;
+}
+function convertTriggers(config, result) {
+	const triggers$1 = config.triggers;
+	if (!triggers$1 || triggers$1.length === 0) return;
+	const crons = [];
+	const routes = result.routes ? [...result.routes] : [];
+	const queueConsumers = result.queues?.consumers ? [...result.queues.consumers] : [];
+	for (const trigger of triggers$1) switch (trigger.type) {
+		case "scheduled":
+			crons.push(trigger.schedule);
+			break;
+		case "fetch":
+			if (trigger.zone === void 0) routes.push(trigger.pattern);
+			else if (trigger.zone.includes(".")) routes.push({
+				pattern: trigger.pattern,
+				zone_name: trigger.zone
+			});
+			else routes.push({
+				pattern: trigger.pattern,
+				zone_id: trigger.zone
+			});
+			break;
+		case "queue":
+			queueConsumers.push(omitUndefined({
+				queue: trigger.name,
+				dead_letter_queue: trigger.deadLetterQueue,
+				max_batch_size: trigger.maxBatchSize,
+				max_batch_timeout: trigger.maxBatchTimeout,
+				max_concurrency: trigger.maxConcurrency,
+				max_retries: trigger.maxRetries,
+				retry_delay: trigger.retryDelay,
+				visibility_timeout_ms: trigger.visibilityTimeoutMs
+			}));
+			break;
+	}
+	if (crons.length) result.triggers = { crons };
+	if (routes.length) result.routes = routes;
+	if (queueConsumers.length) result.queues = {
+		...result.queues ?? {},
+		consumers: queueConsumers
+	};
+}
+function convertDomains(config, result) {
+	if (!config.domains || config.domains.length === 0) return;
+	const routes = result.routes ? [...result.routes] : [];
+	for (const domain of config.domains) routes.push({
+		pattern: domain,
+		custom_domain: true
+	});
+	result.routes = routes;
+}
+function convertTailConsumers(config, result) {
+	const consumers = config.tailConsumers;
+	if (!consumers || consumers.length === 0) return;
+	const tail = [];
+	const streaming = [];
+	for (const consumer of consumers) if (consumer.streaming) streaming.push({ service: consumer.workerName });
+	else tail.push({ service: consumer.workerName });
+	if (tail.length) result.tail_consumers = tail;
+	if (streaming.length) result.streaming_tail_consumers = streaming;
+}
+/**
+* Strip keys whose value is `undefined`. Returns a new object preserving the
+* input's value type.
+*/
+function omitUndefined(obj) {
+	const out = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) out[key] = value;
+	return out;
+}
+
+//#endregion
+//#region src/load.ts
+/**
+* @module
+*
+* The no-cache import logic in this file is adapted from `import-without-cache`
+* by Kevin Deng (https://github.com/sxzz/import-without-cache), published under
+* the MIT License and Copyright © 2025-PRESENT Kevin Deng.
+*
+* See https://github.com/sxzz/import-without-cache for the original code.
+*/
+const CF_WORKER_SCHEME = "cf-worker:";
+const CF_WORKER_TYPE = "cf-worker";
+const CF_ATTR = "cf";
+const CF_NO_CACHE_VALUE = "no-cache";
+const CF_NO_CACHE_QUERY_KEY = "cf-no-cache";
+const RE_NODE_MODULES = /[/\\]node_modules[/\\]/;
+const depsStore = new AsyncLocalStorage();
+/**
+* Dynamically import a worker config file from disk.
+*
+* Returns the module's default export, plus the set of file paths
+* imported during resolution. Callers are responsible for unwrapping
+* function/promise wrappers around the returned value and validating it
+* against `InputWorkerSchema`.
+*
+* @param configPath Filesystem path to the config file. Relative paths are
+*   resolved against `process.cwd()`.
+*/
+async function loadConfig(configPath) {
+	registerConfigHooks();
+	const url = pathToFileURL(configPath).href;
+	const dependencies = /* @__PURE__ */ new Set();
+	return {
+		config: (await depsStore.run(dependencies, () => import(url, { with: { [CF_ATTR]: CF_NO_CACHE_VALUE } }))).default,
+		dependencies
+	};
+}
+let deregister;
+/**
+* Register Node module hooks for loading Worker configs. Idempotent —
+* repeated calls return the same deregister function.
+*
+*  - Handles `with { type: "cf-worker" }` import attributes by synthesising an
+*    ES module whose default export is the entrypoint specifier. Relative
+*    specifiers (`./`, `../`) are anchored to the importing module and emitted
+*    as absolute paths; bare specifiers and virtual-module specifiers pass
+*    through unchanged so consumers can apply their own resolution semantics.
+*    The referenced module is NOT loaded, is NOT executed, and is NOT added to
+*    the dependencies set.
+*  - Handles `with { cf: "no-cache" }` import attributes (set internally by
+*    `loadConfig`) by tagging the resolved URL with a unique UUID query
+*    string so Node treats each import as a fresh module. The UUID is
+*    propagated to all transitive imports via the parent URL, ensuring the
+*    entire subgraph is re-evaluated. Imports inside `node_modules` are
+*    skipped (treated as immutable for config purposes).
+*/
+function registerConfigHooks() {
+	if (deregister) return deregister;
+	if (typeof process !== "undefined" && process.versions.bun) throw new Error("cloudflare.config.ts loading is not supported on Bun. Please use Node.js v22.18.0 or higher.");
+	const registerHooks = nodeModule.registerHooks;
+	if (typeof registerHooks !== "function") throw new Error("cloudflare.config.ts loading requires Node.js v22.18.0 or higher.");
+	const hooks = registerHooks({
+		resolve(specifier, context, nextResolve) {
+			const importAttributes = context.importAttributes ?? {};
+			if (importAttributes.type === CF_WORKER_TYPE) {
+				const entrypoint = (specifier.startsWith("./") || specifier.startsWith("../")) && context.parentURL ? fileURLToPath(new URL(specifier, context.parentURL)) : specifier;
+				return {
+					url: `${CF_WORKER_SCHEME}${encodeURIComponent(entrypoint)}`,
+					format: "module",
+					shortCircuit: true
+				};
+			}
+			const isNoCache = importAttributes[CF_ATTR] === CF_NO_CACHE_VALUE;
+			const resolved = nextResolve(specifier, context);
+			if (RE_NODE_MODULES.test(resolved.url)) return resolved;
+			if (!resolved.url.startsWith("file://")) return resolved;
+			const parentUuid = getParentUUID(context.parentURL);
+			if (!parentUuid && !isNoCache) return resolved;
+			depsStore.getStore()?.add(fileURLToPath(resolved.url));
+			resolved.url = appendUUID(resolved.url, parentUuid || crypto.randomUUID());
+			return resolved;
+		},
+		load(url, context, nextLoad) {
+			if (url.startsWith(CF_WORKER_SCHEME)) {
+				const specifier = decodeURIComponent(url.slice(10));
+				return {
+					format: "module",
+					source: `export default ${JSON.stringify(specifier)};`,
+					shortCircuit: true
+				};
+			}
+			cleanupImportAttributes(context);
+			return nextLoad(url, context);
+		}
+	});
+	deregister = () => {
+		hooks.deregister();
+		deregister = void 0;
+	};
+	return deregister;
+}
+function getParentUUID(parentURL) {
+	if (!parentURL) return;
+	return new URL(parentURL).searchParams.get(CF_NO_CACHE_QUERY_KEY) ?? void 0;
+}
+function appendUUID(url, uuid) {
+	const parsed = new URL(url);
+	parsed.searchParams.set(CF_NO_CACHE_QUERY_KEY, uuid);
+	return parsed.toString();
+}
+function cleanupImportAttributes(context) {
+	if (!context.importAttributes?.[CF_ATTR]) return;
+	const attrs = Object.assign(Object.create(null), context.importAttributes);
+	delete attrs[CF_ATTR];
+	context.importAttributes = attrs;
+	Object.freeze(context.importAttributes);
+}
+
+//#endregion
+export { BUILD_OUTPUT_ROOT, BUILD_OUTPUT_VERSION, InputWorkerSchema, ModuleTypeSchema, OutputWorkerSchema, WORKER_CONFIG_FILENAME, bindings, cleanBuildOutputDir, convertToWranglerConfig, defineWorker, exports$1 as exports, generateTypes, getWorkerAssetsDir, getWorkerBundleDir, getWorkerConfigPath, getWorkersDir, loadConfig, registerConfigHooks, resolveWorkerDefinition, triggers, writeOutputWorkerConfig };