e2sm 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 import { stripVTControlCharacters } from "node:util";
 import y, { stdin, stdout } from "node:process";
 import * as g from "node:readline";
@@ -34,7 +33,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region node_modules/args-tokens/lib/utils-1LQrGCWG.js
@@ -632,7 +630,7 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 				const actualInputName = isShortOption(token.rawName) ? `-${token.name}` : `--${arg}`;
 				actualInputNames.set(rawArg, actualInputName);
 				if (schema.type === "boolean") token.value = void 0;
-				const [parsedValue, error] = parse$1(token, arg, schema);
+				const [parsedValue, error] = parse$2(token, arg, schema);
 				if (error) errors.push(error);
 				else if (schema.multiple) {
 					values[rawArg] ||= [];
@@ -652,7 +650,7 @@ function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKI
 		explicit
 	};
 }
-function parse$1(token, option, schema) {
+function parse$2(token, option, schema) {
 	switch (schema.type) {
 		case "string": return typeof token.value === "string" ? [token.value || schema.default, void 0] : [void 0, createTypeError(option, schema)];
 		case "boolean": return token.value ? [token.value || schema.default, void 0] : [!(schema.negatable && token.name.startsWith("no-")), void 0];
@@ -855,7 +853,7 @@ function resolveDependencies(plugins) {
 		if (pluginMap.has(plugin$1.id)) console.warn(`Duplicate plugin id detected: \`${plugin$1.id}\``);
 		pluginMap.set(plugin$1.id, plugin$1);
 	}
-	function visit(plugin$1) {
+	function visit$2(plugin$1) {
 		if (!plugin$1.id) return;
 		if (visited.has(plugin$1.id)) return;
 		if (visiting.has(plugin$1.id)) throw new Error(`Circular dependency detected: \`${[...visiting].join(` -> `) + " -> " + plugin$1.id}\``);
@@ -866,13 +864,13 @@ function resolveDependencies(plugins) {
 			const isOptional = typeof dep === "string" ? false : dep.optional || false;
 			const depPlugin = pluginMap.get(depId);
 			if (!depPlugin && !isOptional) throw new Error(`Missing required dependency: \`${depId}\` on \`${plugin$1.id}\``);
-			if (depPlugin) visit(depPlugin);
+			if (depPlugin) visit$2(depPlugin);
 		}
 		visiting.delete(plugin$1.id);
 		visited.add(plugin$1.id);
 		sorted.push(plugin$1);
 	}
-	for (const plugin$1 of plugins) visit(plugin$1);
+	for (const plugin$1 of plugins) visit$2(plugin$1);
 	return sorted;
 }
 /**
@@ -1059,7 +1057,7 @@ async function executeCommand(cmd, ctx, decorators) {
 * @param definition - A {@link Command | command} definition
 * @returns A defined {@link Command | command}
 */
-function define$1(definition) {
+function define(definition) {
 	return definition;
 }
 
@@ -1829,7 +1827,7 @@ BUILT_IN_PREFIX.codePointAt(0);
 
 //#endregion
 //#region package.json
-var version = "0.6.1";
+var version = "0.6.2";
 
 //#endregion
 //#region node_modules/sisteransi/src/index.js
@@ -3160,201 +3158,1075 @@ function formatJson(obj, indent = 0) {
 }
 
 //#endregion
-//#region node_modules/jsonc-parser/lib/umd/main.js
-var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	(function(factory) {
-		if (typeof module === "object" && typeof module.exports === "object") {
-			var v$1 = factory(__require, exports);
-			if (v$1 !== void 0) module.exports = v$1;
-		} else if (typeof define === "function" && define.amd) define([
-			"require",
-			"exports",
-			"./impl/format",
-			"./impl/edit",
-			"./impl/scanner",
-			"./impl/parser"
-		], factory);
-	})(function(require, exports$1) {
-		"use strict";
-		Object.defineProperty(exports$1, "__esModule", { value: true });
-		exports$1.applyEdits = exports$1.modify = exports$1.format = exports$1.printParseErrorCode = exports$1.ParseErrorCode = exports$1.stripComments = exports$1.visit = exports$1.getNodeValue = exports$1.getNodePath = exports$1.findNodeAtOffset = exports$1.findNodeAtLocation = exports$1.parseTree = exports$1.parse = exports$1.getLocation = exports$1.SyntaxKind = exports$1.ScanError = exports$1.createScanner = void 0;
-		const formatter = require("./impl/format");
-		const edit = require("./impl/edit");
-		const scanner = require("./impl/scanner");
-		const parser = require("./impl/parser");
-		/**
-		* Creates a JSON scanner on the given text.
-		* If ignoreTrivia is set, whitespaces or comments are ignored.
-		*/
-		exports$1.createScanner = scanner.createScanner;
-		var ScanError;
-		(function(ScanError$1) {
-			ScanError$1[ScanError$1["None"] = 0] = "None";
-			ScanError$1[ScanError$1["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
-			ScanError$1[ScanError$1["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
-			ScanError$1[ScanError$1["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
-			ScanError$1[ScanError$1["InvalidUnicode"] = 4] = "InvalidUnicode";
-			ScanError$1[ScanError$1["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
-			ScanError$1[ScanError$1["InvalidCharacter"] = 6] = "InvalidCharacter";
-		})(ScanError || (exports$1.ScanError = ScanError = {}));
-		var SyntaxKind;
-		(function(SyntaxKind$1) {
-			SyntaxKind$1[SyntaxKind$1["OpenBraceToken"] = 1] = "OpenBraceToken";
-			SyntaxKind$1[SyntaxKind$1["CloseBraceToken"] = 2] = "CloseBraceToken";
-			SyntaxKind$1[SyntaxKind$1["OpenBracketToken"] = 3] = "OpenBracketToken";
-			SyntaxKind$1[SyntaxKind$1["CloseBracketToken"] = 4] = "CloseBracketToken";
-			SyntaxKind$1[SyntaxKind$1["CommaToken"] = 5] = "CommaToken";
-			SyntaxKind$1[SyntaxKind$1["ColonToken"] = 6] = "ColonToken";
-			SyntaxKind$1[SyntaxKind$1["NullKeyword"] = 7] = "NullKeyword";
-			SyntaxKind$1[SyntaxKind$1["TrueKeyword"] = 8] = "TrueKeyword";
-			SyntaxKind$1[SyntaxKind$1["FalseKeyword"] = 9] = "FalseKeyword";
-			SyntaxKind$1[SyntaxKind$1["StringLiteral"] = 10] = "StringLiteral";
-			SyntaxKind$1[SyntaxKind$1["NumericLiteral"] = 11] = "NumericLiteral";
-			SyntaxKind$1[SyntaxKind$1["LineCommentTrivia"] = 12] = "LineCommentTrivia";
-			SyntaxKind$1[SyntaxKind$1["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
-			SyntaxKind$1[SyntaxKind$1["LineBreakTrivia"] = 14] = "LineBreakTrivia";
-			SyntaxKind$1[SyntaxKind$1["Trivia"] = 15] = "Trivia";
-			SyntaxKind$1[SyntaxKind$1["Unknown"] = 16] = "Unknown";
-			SyntaxKind$1[SyntaxKind$1["EOF"] = 17] = "EOF";
-		})(SyntaxKind || (exports$1.SyntaxKind = SyntaxKind = {}));
-		/**
-		* For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
-		*/
-		exports$1.getLocation = parser.getLocation;
-		/**
-		* 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.
-		*/
-		exports$1.parse = parser.parse;
-		/**
-		* 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.
-		*/
-		exports$1.parseTree = parser.parseTree;
-		/**
-		* Finds the node at the given path in a JSON DOM.
-		*/
-		exports$1.findNodeAtLocation = parser.findNodeAtLocation;
-		/**
-		* Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
-		*/
-		exports$1.findNodeAtOffset = parser.findNodeAtOffset;
-		/**
-		* Gets the JSON path of the given JSON DOM node
-		*/
-		exports$1.getNodePath = parser.getNodePath;
-		/**
-		* Evaluates the JavaScript object of the given JSON DOM node
-		*/
-		exports$1.getNodeValue = parser.getNodeValue;
-		/**
-		* Parses the given text and invokes the visitor functions for each object, array and literal reached.
-		*/
-		exports$1.visit = parser.visit;
-		/**
-		* Takes JSON with JavaScript-style comments and remove
-		* them. Optionally replaces every none-newline character
-		* of comments with a replaceCharacter
-		*/
-		exports$1.stripComments = parser.stripComments;
-		var ParseErrorCode;
-		(function(ParseErrorCode$1) {
-			ParseErrorCode$1[ParseErrorCode$1["InvalidSymbol"] = 1] = "InvalidSymbol";
-			ParseErrorCode$1[ParseErrorCode$1["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
-			ParseErrorCode$1[ParseErrorCode$1["PropertyNameExpected"] = 3] = "PropertyNameExpected";
-			ParseErrorCode$1[ParseErrorCode$1["ValueExpected"] = 4] = "ValueExpected";
-			ParseErrorCode$1[ParseErrorCode$1["ColonExpected"] = 5] = "ColonExpected";
-			ParseErrorCode$1[ParseErrorCode$1["CommaExpected"] = 6] = "CommaExpected";
-			ParseErrorCode$1[ParseErrorCode$1["CloseBraceExpected"] = 7] = "CloseBraceExpected";
-			ParseErrorCode$1[ParseErrorCode$1["CloseBracketExpected"] = 8] = "CloseBracketExpected";
-			ParseErrorCode$1[ParseErrorCode$1["EndOfFileExpected"] = 9] = "EndOfFileExpected";
-			ParseErrorCode$1[ParseErrorCode$1["InvalidCommentToken"] = 10] = "InvalidCommentToken";
-			ParseErrorCode$1[ParseErrorCode$1["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
-			ParseErrorCode$1[ParseErrorCode$1["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
-			ParseErrorCode$1[ParseErrorCode$1["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
-			ParseErrorCode$1[ParseErrorCode$1["InvalidUnicode"] = 14] = "InvalidUnicode";
-			ParseErrorCode$1[ParseErrorCode$1["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
-			ParseErrorCode$1[ParseErrorCode$1["InvalidCharacter"] = 16] = "InvalidCharacter";
-		})(ParseErrorCode || (exports$1.ParseErrorCode = ParseErrorCode = {}));
-		function printParseErrorCode$1(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";
+//#region 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$1(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$1 = 0;
+		while (digits < count || !exact) {
+			let ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value$1 = value$1 * 16 + ch - 48;
+			else if (ch >= 65 && ch <= 70) value$1 = value$1 * 16 + ch - 65 + 10;
+			else if (ch >= 97 && ch <= 102) value$1 = value$1 * 16 + ch - 97 + 10;
+			else break;
+			pos++;
+			digits++;
+		}
+		if (digits < count) value$1 = -1;
+		return value$1;
+	}
+	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);
 			}
-			return "<unknown ParseErrorCode>";
 		}
-		exports$1.printParseErrorCode = printParseErrorCode$1;
-		/**
-		* Computes the edit operations needed to format a JSON document.
-		*
-		* @param documentText The input text
-		* @param range The range to format or `undefined` to format the full content
-		* @param options The formatting options
-		* @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
-		* To apply the edit operations to the input, use {@linkcode applyEdits}.
-		*/
-		function format(documentText, range, options) {
-			return formatter.format(documentText, range, options);
+		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;
 		}
-		exports$1.format = format;
-		/**
-		* 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 edit.setProperty(text, path, value, options);
+		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++;
 		}
-		exports$1.modify = modify;
-		/**
-		* 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$2) => {
-				const diff = a.offset - b$2.offset;
-				if (diff === 0) return a.length - b$2.length;
-				return diff;
+		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/jsonc-parser/lib/esm/impl/string-intern.js
+const cachedSpaces = new Array(20).fill(0).map((_$2, index) => {
+	return " ".repeat(index);
+});
+const maxCachedValues = 200;
+const cachedBreakLinesWithSpaces = {
+	" ": {
+		"\n": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\n" + " ".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\r" + " ".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\r\n" + " ".repeat(index);
+		})
+	},
+	"	": {
+		"\n": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\n" + "	".repeat(index);
+		}),
+		"\r": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\r" + "	".repeat(index);
+		}),
+		"\r\n": new Array(maxCachedValues).fill(0).map((_$2, index) => {
+			return "\r\n" + "	".repeat(index);
+		})
+	}
+};
+
+//#endregion
+//#region node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions) {
+	ParseOptions.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+/**
+* For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+*/
+function getLocation$1(text, position) {
+	const segments = [];
+	const earlyReturnException = /* @__PURE__ */ new Object();
+	let previousNode = void 0;
+	const previousNodeInst = {
+		value: {},
+		offset: 0,
+		length: 0,
+		type: "object",
+		parent: void 0
+	};
+	let isAtPropertyKey = false;
+	function setPreviousNode(value, offset, length, type) {
+		previousNodeInst.value = value;
+		previousNodeInst.offset = offset;
+		previousNodeInst.length = length;
+		previousNodeInst.type = type;
+		previousNodeInst.colonOffset = void 0;
+		previousNode = previousNodeInst;
+	}
+	try {
+		visit$1(text, {
+			onObjectBegin: (offset, length) => {
+				if (position <= offset) throw earlyReturnException;
+				previousNode = void 0;
+				isAtPropertyKey = position > offset;
+				segments.push("");
+			},
+			onObjectProperty: (name, offset, length) => {
+				if (position < offset) throw earlyReturnException;
+				setPreviousNode(name, offset, length, "property");
+				segments[segments.length - 1] = name;
+				if (position <= offset + length) throw earlyReturnException;
+			},
+			onObjectEnd: (offset, length) => {
+				if (position <= offset) throw earlyReturnException;
+				previousNode = void 0;
+				segments.pop();
+			},
+			onArrayBegin: (offset, length) => {
+				if (position <= offset) throw earlyReturnException;
+				previousNode = void 0;
+				segments.push(0);
+			},
+			onArrayEnd: (offset, length) => {
+				if (position <= offset) throw earlyReturnException;
+				previousNode = void 0;
+				segments.pop();
+			},
+			onLiteralValue: (value, offset, length) => {
+				if (position < offset) throw earlyReturnException;
+				setPreviousNode(value, offset, length, getNodeType(value));
+				if (position <= offset + length) throw earlyReturnException;
+			},
+			onSeparator: (sep, offset, length) => {
+				if (position <= offset) throw earlyReturnException;
+				if (sep === ":" && previousNode && previousNode.type === "property") {
+					previousNode.colonOffset = offset;
+					isAtPropertyKey = false;
+					previousNode = void 0;
+				} else if (sep === ",") {
+					const last = segments[segments.length - 1];
+					if (typeof last === "number") segments[segments.length - 1] = last + 1;
+					else {
+						isAtPropertyKey = true;
+						segments[segments.length - 1] = "";
+					}
+					previousNode = void 0;
+				}
+			}
+		});
+	} catch (e$1) {
+		if (e$1 !== earlyReturnException) throw e$1;
+	}
+	return {
+		path: segments,
+		previousNode,
+		isAtPropertyKey,
+		matches: (pattern) => {
+			let k$2 = 0;
+			for (let i = 0; k$2 < pattern.length && i < segments.length; i++) if (pattern[k$2] === segments[i] || pattern[k$2] === "*") k$2++;
+			else if (pattern[k$2] !== "**") return false;
+			return k$2 === pattern.length;
+		}
+	};
+}
+/**
+* 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$1(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$1(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$1(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: []
 			});
-			let lastModifiedOffset = text.length;
-			for (let i = sortedEdits.length - 1; i >= 0; i--) {
-				let e$1 = sortedEdits[i];
-				if (e$1.offset + e$1.length <= lastModifiedOffset) text = edit.applyEdit(text, e$1);
-				else throw new Error("Overlapping edit");
-				lastModifiedOffset = e$1.offset;
+		},
+		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);
 			}
-			return text;
+		},
+		onError: (error, offset, length) => {
+			errors.push({
+				error,
+				offset,
+				length
+			});
 		}
-		exports$1.applyEdits = applyEdits;
-	});
-}));
+	}, 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$1(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;
+}
+/**
+* Gets the JSON path of the given JSON DOM node
+*/
+function getNodePath$1(node) {
+	if (!node.parent || !node.parent.children) return [];
+	const path = getNodePath$1(node.parent);
+	if (node.parent.type === "property") {
+		const key = node.parent.children[0].value;
+		path.push(key);
+	} else if (node.parent.type === "array") {
+		const index = node.parent.children.indexOf(node);
+		if (index !== -1) path.push(index);
+	}
+	return path;
+}
+/**
+* Evaluates the JavaScript object of the given JSON DOM node
+*/
+function getNodeValue$1(node) {
+	switch (node.type) {
+		case "array": return node.children.map(getNodeValue$1);
+		case "object":
+			const obj = Object.create(null);
+			for (let prop of node.children) {
+				const valueNode = prop.children[1];
+				if (valueNode) obj[prop.children[0].value] = getNodeValue$1(valueNode);
+			}
+			return obj;
+		case "null":
+		case "string":
+		case "number":
+		case "boolean": return node.value;
+		default: return;
+	}
+}
+function contains(node, offset, includeRightBound = false) {
+	return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
+}
+/**
+* Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+*/
+function findNodeAtOffset$1(node, offset, includeRightBound = false) {
+	if (contains(node, offset, includeRightBound)) {
+		const children = node.children;
+		if (Array.isArray(children)) for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+			const item = findNodeAtOffset$1(children[i], offset, includeRightBound);
+			if (item) return item;
+		}
+		return node;
+	}
+}
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+function visit$1(text, visitor, options = ParseOptions.DEFAULT) {
+	const _scanner = createScanner$1(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);
+					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;
+			}
+		}
+	}
+	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;
+}
+/**
+* Takes JSON with JavaScript-style comments and remove
+* them. Optionally replaces every none-newline character
+* of comments with a replaceCharacter
+*/
+function stripComments$1(text, replaceCh) {
+	let _scanner = createScanner$1(text), parts = [], kind, offset = 0, pos;
+	do {
+		pos = _scanner.getPosition();
+		kind = _scanner.scan();
+		switch (kind) {
+			case 12:
+			case 13:
+			case 17:
+				if (offset !== pos) parts.push(text.substring(offset, pos));
+				if (replaceCh !== void 0) parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+				offset = _scanner.getPosition();
+				break;
+		}
+	} while (kind !== 17);
+	return parts.join("");
+}
+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/jsonc-parser/lib/esm/main.js
+/**
+* Creates a JSON scanner on the given text.
+* If ignoreTrivia is set, whitespaces or comments are ignored.
+*/
+const createScanner = createScanner$1;
+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 = {}));
+/**
+* For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+*/
+const getLocation = getLocation$1;
+/**
+* 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;
+/**
+* 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.
+*/
+const parseTree = parseTree$1;
+/**
+* Finds the node at the given path in a JSON DOM.
+*/
+const findNodeAtLocation = findNodeAtLocation$1;
+/**
+* Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+*/
+const findNodeAtOffset = findNodeAtOffset$1;
+/**
+* Gets the JSON path of the given JSON DOM node
+*/
+const getNodePath = getNodePath$1;
+/**
+* Evaluates the JavaScript object of the given JSON DOM node
+*/
+const getNodeValue = getNodeValue$1;
+/**
+* Parses the given text and invokes the visitor functions for each object, array and literal reached.
+*/
+const visit = visit$1;
+/**
+* Takes JSON with JavaScript-style comments and remove
+* them. Optionally replaces every none-newline character
+* of comments with a replaceCharacter
+*/
+const stripComments = stripComments$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>";
+}
 
 //#endregion
 //#region src/lib/config.ts
-var import_main = require_main();
 /**
 * Loads config from .e2smrc.jsonc or .e2smrc.json (project or global).
 * Searches in order: .jsonc (preferred) then .json (backward compatibility).
@@ -3378,9 +4250,9 @@ async function loadConfig() {
 			continue;
 		}
 		const errors = [];
-		const config = (0, import_main.parse)(content, errors, { allowTrailingComma: true });
+		const config = parse(content, errors, { allowTrailingComma: true });
 		if (errors.length > 0) {
-			const errorMessages = errors.map((e$1) => (0, import_main.printParseErrorCode)(e$1.error)).join(", ");
+			const errorMessages = errors.map((e$1) => printParseErrorCode(e$1.error)).join(", ");
 			console.warn(`Warning: Parse error in ${filePath}: ${errorMessages}`);
 			console.warn("Skipping this config file and trying next candidate...");
 			continue;
@@ -3452,7 +4324,7 @@ function isCancel$3(value) {
 }
 const MIN_RECOVERY_DAYS = 7;
 const MAX_RECOVERY_DAYS = 30;
-const deleteCommand = define$1({
+const deleteCommand = define({
 	name: "delete",
 	description: "Delete secret from AWS Secrets Manager",
 	args: {
@@ -3592,7 +4464,7 @@ const deleteCommand = define$1({
 function isCancel$2(value) {
 	return pD(value);
 }
-const getCommand = define$1({
+const getCommand = define({
 	name: "get",
 	description: "Get secret value from AWS Secrets Manager",
 	args: {
@@ -3695,7 +4567,7 @@ var template_default = "{\n  \"$schema\": \"https://unpkg.com/e2sm/assets/schema
 //#endregion
 //#region src/commands/init.ts
 const CONFIG_FILE = ".e2smrc.jsonc";
-const initCommand = define$1({
+const initCommand = define({
 	name: "init",
 	description: "Initialize a new .e2smrc.jsonc configuration file",
 	args: { force: {
@@ -3739,7 +4611,7 @@ const initCommand = define$1({
 function isCancel$1(value) {
 	return pD(value);
 }
-const pullCommand = define$1({
+const pullCommand = define({
 	name: "pull",
 	description: "Pull secret from AWS Secrets Manager and generate .env file",
 	args: {
@@ -3911,7 +4783,7 @@ const pullCommand = define$1({
 function isCancel(value) {
 	return pD(value);
 }
-const setCommand = define$1({
+const setCommand = define({
 	name: "set",
 	description: "Upload .env file to AWS Secrets Manager",
 	args: {
@@ -4127,7 +4999,7 @@ const setCommand = define$1({
 
 //#endregion
 //#region src/index.ts
-const command = define$1({
+const command = define({
 	name: "e2sm",
 	description: "Manage environment variables with AWS Secrets Manager",
 	run: () => {