@coffre/cli 0.1.13 → 0.1.15

package/dist/deployment-Di8BG9qY.js

@@ -0,0 +1,1456 @@
+import { r as isEmpty } from "./init-2xGelVG1.js";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+/**
+* Creates a JSON scanner on the given text.
+* If ignoreTrivia is set, whitespaces or comments are ignored.
+*/
+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 value = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value = value * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value = value * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value = value * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value = -1;
+		return value;
+	}
+	function setPosition(newPosition) {
+		pos = newPosition;
+		value = "";
+		tokenOffset = 0;
+		token = 16;
+		scanError = 0;
+	}
+	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);
+	}
+	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;
+	}
+	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;
+		}
+	}
+	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;
+	}
+	function scanNextNonTrivia() {
+		let result;
+		do
+			result = scanNext();
+		while (result >= 12 && result <= 15);
+		return result;
+	}
+	return {
+		setPosition,
+		getPosition: () => pos,
+		scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+		getToken: () => token,
+		getTokenValue: () => value,
+		getTokenOffset: () => tokenOffset,
+		getTokenLength: () => pos - tokenOffset,
+		getTokenStartLine: () => lineStartOffset,
+		getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+		getTokenError: () => scanError
+	};
+}
+function isWhiteSpace(ch) {
+	return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+	return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+	return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes) {
+	CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+	CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+	CharacterCodes[CharacterCodes["space"] = 32] = "space";
+	CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+	CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+	CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+	CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+	CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+	CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+	CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+	CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+	CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+	CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+	CharacterCodes[CharacterCodes["a"] = 97] = "a";
+	CharacterCodes[CharacterCodes["b"] = 98] = "b";
+	CharacterCodes[CharacterCodes["c"] = 99] = "c";
+	CharacterCodes[CharacterCodes["d"] = 100] = "d";
+	CharacterCodes[CharacterCodes["e"] = 101] = "e";
+	CharacterCodes[CharacterCodes["f"] = 102] = "f";
+	CharacterCodes[CharacterCodes["g"] = 103] = "g";
+	CharacterCodes[CharacterCodes["h"] = 104] = "h";
+	CharacterCodes[CharacterCodes["i"] = 105] = "i";
+	CharacterCodes[CharacterCodes["j"] = 106] = "j";
+	CharacterCodes[CharacterCodes["k"] = 107] = "k";
+	CharacterCodes[CharacterCodes["l"] = 108] = "l";
+	CharacterCodes[CharacterCodes["m"] = 109] = "m";
+	CharacterCodes[CharacterCodes["n"] = 110] = "n";
+	CharacterCodes[CharacterCodes["o"] = 111] = "o";
+	CharacterCodes[CharacterCodes["p"] = 112] = "p";
+	CharacterCodes[CharacterCodes["q"] = 113] = "q";
+	CharacterCodes[CharacterCodes["r"] = 114] = "r";
+	CharacterCodes[CharacterCodes["s"] = 115] = "s";
+	CharacterCodes[CharacterCodes["t"] = 116] = "t";
+	CharacterCodes[CharacterCodes["u"] = 117] = "u";
+	CharacterCodes[CharacterCodes["v"] = 118] = "v";
+	CharacterCodes[CharacterCodes["w"] = 119] = "w";
+	CharacterCodes[CharacterCodes["x"] = 120] = "x";
+	CharacterCodes[CharacterCodes["y"] = 121] = "y";
+	CharacterCodes[CharacterCodes["z"] = 122] = "z";
+	CharacterCodes[CharacterCodes["A"] = 65] = "A";
+	CharacterCodes[CharacterCodes["B"] = 66] = "B";
+	CharacterCodes[CharacterCodes["C"] = 67] = "C";
+	CharacterCodes[CharacterCodes["D"] = 68] = "D";
+	CharacterCodes[CharacterCodes["E"] = 69] = "E";
+	CharacterCodes[CharacterCodes["F"] = 70] = "F";
+	CharacterCodes[CharacterCodes["G"] = 71] = "G";
+	CharacterCodes[CharacterCodes["H"] = 72] = "H";
+	CharacterCodes[CharacterCodes["I"] = 73] = "I";
+	CharacterCodes[CharacterCodes["J"] = 74] = "J";
+	CharacterCodes[CharacterCodes["K"] = 75] = "K";
+	CharacterCodes[CharacterCodes["L"] = 76] = "L";
+	CharacterCodes[CharacterCodes["M"] = 77] = "M";
+	CharacterCodes[CharacterCodes["N"] = 78] = "N";
+	CharacterCodes[CharacterCodes["O"] = 79] = "O";
+	CharacterCodes[CharacterCodes["P"] = 80] = "P";
+	CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+	CharacterCodes[CharacterCodes["R"] = 82] = "R";
+	CharacterCodes[CharacterCodes["S"] = 83] = "S";
+	CharacterCodes[CharacterCodes["T"] = 84] = "T";
+	CharacterCodes[CharacterCodes["U"] = 85] = "U";
+	CharacterCodes[CharacterCodes["V"] = 86] = "V";
+	CharacterCodes[CharacterCodes["W"] = 87] = "W";
+	CharacterCodes[CharacterCodes["X"] = 88] = "X";
+	CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+	CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+	CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+	CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+	CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+	CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+	CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+	CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+	CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+	CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+	CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+	CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+	CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+	CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+	CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+	CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+	CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+const cachedSpaces = new Array(20).fill(0).map((_, index) => {
+	return " ".repeat(index);
+});
+const maxCachedValues = 200;
+const cachedBreakLinesWithSpaces = {
+	" ": {
+		"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\n" + " ".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r" + " ".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r\n" + " ".repeat(index);
+		})
+	},
+	"	": {
+		"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\n" + "	".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r" + "	".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+			return "\r\n" + "	".repeat(index);
+		})
+	}
+};
+const supportedEols = [
+	"\n",
+	"\r",
+	"\r\n"
+];
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+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);
+	const eolFastPathSupported = supportedEols.includes(eol);
+	let numberLineBreaks = 0;
+	let indentLevel = 0;
+	let indentValue;
+	if (options.insertSpaces) indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+	else indentValue = "	";
+	const indentType = indentValue === "	" ? "	" : " ";
+	let scanner = createScanner(formatText, false);
+	let hasError = false;
+	function newLinesAndIndent() {
+		if (numberLineBreaks > 1) return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+		const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+		if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+		if (amountOfSpaces <= 0) return eol;
+		return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+	}
+	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;
+	}
+	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
+		});
+	}
+	let firstToken = scanNext();
+	if (options.keepLines && numberLineBreaks > 0) addEdit(repeat(eol, numberLineBreaks), 0, 0);
+	if (firstToken !== 17) {
+		let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+		addEdit(indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : 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(cachedSpaces[1], 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 = cachedSpaces[1];
+		} else if (secondToken === 4) {
+			if (firstToken !== 3) indentLevel--;
+			if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) replaceContent = newLinesAndIndent();
+			else if (options.keepLines) replaceContent = cachedSpaces[1];
+		} else {
+			switch (firstToken) {
+				case 3:
+				case 1:
+					indentLevel++;
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = cachedSpaces[1];
+					break;
+				case 5:
+					if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+					else replaceContent = cachedSpaces[1];
+					break;
+				case 12:
+					replaceContent = newLinesAndIndent();
+					break;
+				case 13:
+					if (numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = cachedSpaces[1];
+					break;
+				case 6:
+					if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+					else if (!needsLineBreak) replaceContent = cachedSpaces[1];
+					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 = cachedSpaces[1];
+					else if (secondToken !== 5 && secondToken !== 17) hasError = true;
+					break;
+				case 16: hasError = true;
+			}
+			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;
+}
+function repeat(s, count) {
+	let result = "";
+	for (let i = 0; i < count; i++) result += s;
+	return result;
+}
+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 === cachedSpaces[1]) nChars++;
+		else if (ch === "	") nChars += tabSize;
+		else break;
+		i++;
+	}
+	return Math.floor(nChars / tabSize);
+}
+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";
+}
+function isEOL(text, offset) {
+	return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+	ParseOptions.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore always check the errors list to find out if the input was valid.
+*/
+function parse$1(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;
+	}
+	visit(text, {
+		onObjectBegin: () => {
+			const object = {};
+			onValue(object);
+			previousParents.push(currentParent);
+			currentParent = object;
+			currentProperty = null;
+		},
+		onObjectProperty: (name) => {
+			currentProperty = name;
+		},
+		onObjectEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onArrayBegin: () => {
+			const array = [];
+			onValue(array);
+			previousParents.push(currentParent);
+			currentParent = array;
+			currentProperty = null;
+		},
+		onArrayEnd: () => {
+			currentParent = previousParents.pop();
+		},
+		onLiteralValue: onValue,
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	return currentParent[0];
+}
+/**
+* Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+*/
+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;
+		}
+	}
+	function onValue(valueNode) {
+		currentParent.children.push(valueNode);
+		return valueNode;
+	}
+	visit(text, {
+		onObjectBegin: (offset) => {
+			currentParent = onValue({
+				type: "object",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		},
+		onObjectProperty: (name, offset, length) => {
+			currentParent = onValue({
+				type: "property",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+			currentParent.children.push({
+				type: "string",
+				value: name,
+				offset,
+				length,
+				parent: currentParent
+			});
+		},
+		onObjectEnd: (offset, length) => {
+			ensurePropertyComplete(offset + length);
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		},
+		onArrayBegin: (offset, length) => {
+			currentParent = onValue({
+				type: "array",
+				offset,
+				length: -1,
+				parent: currentParent,
+				children: []
+			});
+		},
+		onArrayEnd: (offset, length) => {
+			currentParent.length = offset + length - currentParent.offset;
+			currentParent = currentParent.parent;
+			ensurePropertyComplete(offset + length);
+		},
+		onLiteralValue: (value, offset, length) => {
+			onValue({
+				type: getNodeType(value),
+				offset,
+				length,
+				parent: currentParent,
+				value
+			});
+			ensurePropertyComplete(offset + length);
+		},
+		onSeparator: (sep, offset, length) => {
+			if (currentParent.type === "property") {
+				if (sep === ":") currentParent.colonOffset = offset;
+				else if (sep === ",") ensurePropertyComplete(offset);
+			}
+		},
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
+		}
+	}, options);
+	const result = currentParent.children[0];
+	if (result) delete result.parent;
+	return result;
+}
+/**
+* Finds the node at the given path in a JSON DOM.
+*/
+function findNodeAtLocation(root, path) {
+	if (!root) return;
+	let node = root;
+	for (let segment of path) 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;
+}
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner(text, false);
+	const _jsonPath = [];
+	let suppressedCallbacks = 0;
+	function toNoArgVisit(visitFunction) {
+		return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisit(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+	}
+	function toOneArgVisitWithPath(visitFunction) {
+		return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+	}
+	function toBeginVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks++;
+			else if (visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) === false) suppressedCallbacks = 1;
+		} : () => true;
+	}
+	function toEndVisit(visitFunction) {
+		return visitFunction ? () => {
+			if (suppressedCallbacks > 0) suppressedCallbacks--;
+			if (suppressedCallbacks === 0) visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+		} : () => true;
+	}
+	const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(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);
+			}
+			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;
+			}
+		}
+	}
+	function handleError(error, skipUntilAfter = [], skipUntil = []) {
+		onError(error);
+		if (skipUntilAfter.length + skipUntil.length > 0) {
+			let token = _scanner.getToken();
+			while (token !== 17) {
+				if (skipUntilAfter.indexOf(token) !== -1) {
+					scanNext();
+					break;
+				} else if (skipUntil.indexOf(token) !== -1) break;
+				token = scanNext();
+			}
+		}
+	}
+	function parseString(isValue) {
+		const value = _scanner.getTokenValue();
+		if (isValue) onLiteralValue(value);
+		else {
+			onObjectProperty(value);
+			_jsonPath.push(value);
+		}
+		scanNext();
+		return true;
+	}
+	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;
+	}
+	function parseProperty() {
+		if (_scanner.getToken() !== 10) {
+			handleError(3, [], [2, 5]);
+			return false;
+		}
+		parseString(false);
+		if (_scanner.getToken() === 6) {
+			onSeparator(":");
+			scanNext();
+			if (!parseValue()) handleError(4, [], [2, 5]);
+		} else handleError(5, [], [2, 5]);
+		_jsonPath.pop();
+		return true;
+	}
+	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;
+	}
+	function parseArray() {
+		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 (!parseValue()) handleError(4, [], [4, 5]);
+			needsComma = true;
+		}
+		onArrayEnd();
+		if (!isFirstElement) _jsonPath.pop();
+		if (_scanner.getToken() !== 4) handleError(8, [4], []);
+		else scanNext();
+		return true;
+	}
+	function parseValue() {
+		switch (_scanner.getToken()) {
+			case 3: return parseArray();
+			case 1: return parseObject();
+			case 10: return parseString(true);
+			default: return parseLiteral();
+		}
+	}
+	scanNext();
+	if (_scanner.getToken() === 17) {
+		if (options.allowEmptyContent) return true;
+		handleError(4, [], []);
+		return false;
+	}
+	if (!parseValue()) {
+		handleError(4, [], []);
+		return false;
+	}
+	if (_scanner.getToken() !== 17) handleError(9, [], []);
+	return true;
+}
+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";
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+	const path = originalPath.slice();
+	const root = parseTree(text, []);
+	let parent = void 0;
+	let lastSegment = void 0;
+	while (path.length > 0) {
+		lastSegment = path.pop();
+		parent = findNodeAtLocation(root, path);
+		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}`);
+}
+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 edit = edits[i];
+		newText = applyEdit(newText, edit);
+		begin = Math.min(begin, edit.offset);
+		end = Math.max(end, edit.offset + edit.length);
+		end += edit.content.length - edit.length;
+	}
+	const editLength = text.length - (newText.length - end) - begin;
+	return [{
+		offset: begin,
+		length: editLength,
+		content: newText.substring(begin, end)
+	}];
+}
+function applyEdit(text, edit) {
+	return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError) {
+	ScanError[ScanError["None"] = 0] = "None";
+	ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+	ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+	ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+	ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+	ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+	ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind) {
+	SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+	SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+	SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+	SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+	SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+	SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+	SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+	SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+	SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+	SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+	SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+	SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+	SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+	SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+	SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+	SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+	SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+/**
+* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+* Therefore, always check the errors list to find out if the input was valid.
+*/
+const parse = parse$1;
+var ParseErrorCode;
+(function(ParseErrorCode) {
+	ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+	ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+	ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+	ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+	ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+	ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+	ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+	ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+	ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+	ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+	ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+	ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+	ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+	ParseErrorCode[ParseErrorCode["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>";
+}
+/**
+* Computes the edit operations needed to modify a value in the JSON document.
+*
+* @param documentText The input text
+* @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+* If the path points to an non-existing property or item, it will be created.
+* @param value The new value for the specified property or item. If the value is undefined,
+* the property or item will be removed.
+* @param options Options
+* @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+* To apply the edit operations to the input, use {@linkcode applyEdits}.
+*/
+function modify(text, path, value, options) {
+	return setProperty(text, path, value, options);
+}
+/**
+* Applies edits to an input string.
+* @param text The input text
+* @param edits Edit operations following the format described in {@linkcode EditResult}.
+* @returns The text with the applied edits.
+* @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+*/
+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;
+}
+//#endregion
+//#region src/deployment.ts
+/** What a directory holds: a deployment of either kind, nothing yet (`isEmpty`), or something else. */
+function deploymentKind(dir) {
+	if (isEmpty(dir)) return "empty";
+	if (existsSync(join(dir, "app", "wrangler.jsonc")) && existsSync(join(dir, "vault", "wrangler.jsonc"))) return "workers";
+	if (existsSync(join(dir, "src", "vault.ts")) && existsSync(join(dir, "vault.env.example"))) return "node";
+	return "other";
+}
+/** Install a new deployment's packages, as its README says: pnpm, through corepack when pnpm itself is missing. */
+function install(dir) {
+	const attempt = (command, args) => new Promise((resolve) => {
+		const child = spawn(command, args, {
+			cwd: dir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				COREPACK_ENABLE_DOWNLOAD_PROMPT: "0"
+			}
+		});
+		let output = "";
+		child.stdout.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.stderr.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.on("error", () => resolve(null));
+		child.on("close", (code) => resolve({
+			code,
+			output
+		}));
+	});
+	return (async () => {
+		const ran = await attempt("pnpm", ["install"]) ?? await attempt("corepack", ["pnpm", "install"]);
+		if (ran === null) throw new Error("pnpm is not installed: corepack enable, or npm install -g pnpm, then run setup again");
+		if (ran.code !== 0) {
+			const held = heldBack(ran.output);
+			throw held.length > 0 ? new HeldBack(held, installFailure(ran.output)) : new Error(installFailure(ran.output));
+		}
+	})();
+}
+/** A deployment's `@coffre/*` pins, as its package.json has them. */
+function coffrePins(dir) {
+	const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	const pins = {};
+	for (const field of ["dependencies", "devDependencies"]) for (const [name, version] of Object.entries(manifest[field] ?? {})) if (name.startsWith("@coffre/")) pins[name] = version;
+	return pins;
+}
+/**
+* Every `@coffre/*` pin in `dir`'s package.json, moved to `version`; the
+* rest left as it is. What `pnpm bump` does to the examples, which `coffre
+* init` copies.
+*/
+function bumpPins(dir, version) {
+	const path = join(dir, "package.json");
+	const manifest = JSON.parse(readFileSync(path, "utf8"));
+	for (const field of ["dependencies", "devDependencies"]) for (const name of Object.keys(manifest[field] ?? {})) if (name.startsWith("@coffre/")) manifest[field][name] = version;
+	writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+/** pnpm install refused packages younger than the deployment's minimumReleaseAge. */
+var HeldBack = class extends Error {
+	held;
+	constructor(held, message) {
+		super(message);
+		this.held = held;
+	}
+};
+/** The packages pnpm held back, as its error names them. */
+function heldBack(output) {
+	if (!output.includes("MINIMUM_RELEASE_AGE")) return [];
+	return [...output.matchAll(/^\s*(\S+@\d\S*) was published at (\S+?),?\s/gm)].map((match) => ({
+		spec: match[1],
+		publishedAt: new Date(match[2])
+	}));
+}
+/** The deployment's minimumReleaseAge, in minutes, as its pnpm-workspace.yaml sets it; pnpm's own default, none, without one. */
+function minimumReleaseAge(dir) {
+	const path = join(dir, "pnpm-workspace.yaml");
+	const match = existsSync(path) ? /^minimumReleaseAge:\s*(\d+)/m.exec(readFileSync(path, "utf8")) : null;
+	return match === null ? 0 : Number(match[1]);
+}
+/** How every temporary exclusion `coffre update` writes ends: with when it lapses. */
+const EXCLUDED = /^\s*- '([^']+)' # coffre update: until (\S+)/;
+/**
+* Exclude `held` from minimumReleaseAge, each until it clears, named in the
+* deployment's pnpm-workspace.yaml with that date: never silently, and
+* removed by `removeCleared` once the date has passed.
+*/
+function excludeUntil(dir, held, reason) {
+	const path = join(dir, "pnpm-workspace.yaml");
+	const lines = (existsSync(path) ? readFileSync(path, "utf8") : "").replace(/\n*$/, "").split("\n");
+	const entries = held.map(({ spec, clears }) => `  - '${spec}' # coffre update: until ${clears.toISOString()}, ${reason}`);
+	const key = lines.findIndex((line) => /^minimumReleaseAgeExclude:/.test(line));
+	if (key === -1) lines.push("minimumReleaseAgeExclude:", ...entries);
+	else {
+		let end = key + 1;
+		while (end < lines.length && /^\s+(-|#)/.test(lines[end])) end++;
+		lines.splice(end, 0, ...entries);
+	}
+	writeFileSync(path, `${lines.join("\n")}\n`);
+}
+/** Remove the exclusions `excludeUntil` wrote whose date has passed; the packages they named. */
+function removeCleared(dir, now) {
+	const path = join(dir, "pnpm-workspace.yaml");
+	if (!existsSync(path)) return [];
+	const removed = [];
+	const kept = readFileSync(path, "utf8").split("\n").filter((line) => {
+		const match = EXCLUDED.exec(line);
+		if (match === null || new Date(match[2].replace(/,$/, "")) > now) return true;
+		removed.push(match[1]);
+		return false;
+	});
+	if (removed.length > 0) writeFileSync(path, kept.join("\n"));
+	return removed;
+}
+/**
+* The pnpm a deployment runs, `packageManager` in its package.json, set to
+* `wanted`, coffre's: then a laptop, CI and Workers Builds all install with
+* one pnpm, which holds minimumReleaseAge alike. The value it had, when it
+* changed; null when it was right already.
+*/
+function pinPackageManager(dir, wanted) {
+	const path = join(dir, "package.json");
+	const manifest = JSON.parse(readFileSync(path, "utf8"));
+	if (manifest.packageManager === wanted) return null;
+	const was = manifest.packageManager;
+	let next;
+	if (was !== void 0) next = {
+		...manifest,
+		packageManager: wanted
+	};
+	else {
+		const after = "private" in manifest ? "private" : "name";
+		next = {};
+		for (const [field, value] of Object.entries(manifest)) {
+			next[field] = value;
+			if (field === after) next.packageManager = wanted;
+		}
+		next.packageManager ??= wanted;
+	}
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return was;
+}
+/**
+* Why pnpm install failed, in a sentence. The deployment's minimumReleaseAge
+* holds back every package published within the week, coffre's own
+* excepted, and that includes what coffre's packages depend on: say which,
+* and what to do, rather than pnpm's last lines.
+*/
+function installFailure(output) {
+	if (output.includes("MINIMUM_RELEASE_AGE")) {
+		const held = [...output.matchAll(/^\s*(\S+@\d\S*) was published at/gm)].map((match) => match[1]);
+		return `pnpm held back ${held.length === 0 ? "packages" : held.join(", ")}: published within this deployment's minimumReleaseAge (pnpm-workspace.yaml), a week. Install again once they are a week old, or add them to minimumReleaseAgeExclude if you trust them`;
+	}
+	return `pnpm install failed: ${output.trim().split("\n").slice(-3).join(" ")}`;
+}
+/** A value the examples ship, standing for the operator's own. */
+function placeholder(value) {
+	return value === void 0 || value === null || value === "" || /^replace-with-|example\.com\b/.test(value);
+}
+function readWorker(dir, path) {
+	const errors = [];
+	const config = parse(readFileSync(join(dir, path), "utf8"), errors, { allowTrailingComma: true });
+	if (errors.length > 0) throw new Error(`${path} is not valid: ${printParseErrorCode(errors[0].error)} at offset ${errors[0].offset}`);
+	if (typeof config.name !== "string") throw new Error(`${path} names no Worker`);
+	const route = config.routes?.[0];
+	return {
+		path,
+		name: config.name,
+		accountId: config.account_id ?? null,
+		vars: Object.fromEntries(Object.entries(config.vars ?? {}).filter((entry) => typeof entry[1] === "string")),
+		hyperdrive: placeholder(config.hyperdrive?.[0]?.id) ? null : config.hyperdrive[0].id,
+		route: typeof route === "string" ? route : route?.pattern ?? null
+	};
+}
+/** A value as the examples write one on a single line: `[{ "pattern": "…", "custom_domain": true }]`. */
+function inline(value) {
+	return JSON.stringify(value, null, 1).replace(/\n\s*/g, " ").replace(/\[ /g, "[").replace(/ \]/g, "]");
+}
+/** Make `changes` to the file at `path`, leaving the rest as it is, comments and all. Says which changed anything. */
+function editWorker(dir, path, changes) {
+	const MARK = "\0coffre\0";
+	let text = readFileSync(join(dir, path), "utf8");
+	const changed = changes.map((change) => {
+		const edits = modify(text, change.path, MARK, {
+			formattingOptions: {
+				insertSpaces: true,
+				tabSize: 2,
+				eol: "\n"
+			},
+			getInsertionIndex: change.after === void 0 ? void 0 : (properties) => properties.indexOf(change.after) + 1
+		});
+		const before = text;
+		text = applyEdits(text, edits.map((edit) => ({
+			...edit,
+			content: edit.content.replace(JSON.stringify(MARK), inline(change.value))
+		})));
+		return text !== before;
+	});
+	writeFileSync(join(dir, path), text);
+	return changed;
+}
+//#endregion
+export { editWorker as a, minimumReleaseAge as c, readWorker as d, removeCleared as f, deploymentKind as i, pinPackageManager as l, bumpPins as n, excludeUntil as o, coffrePins as r, install as s, HeldBack as t, placeholder as u };