@skaldapp/monaco-sfc 1.3.1 → 1.3.3

package/dist/vue.worker.js

@@ -11351,7 +11351,7 @@ var shared_esm_bundler_exports = /* @__PURE__ */ __exportAll({
 	toTypeString: () => toTypeString
 });
 /**
-* @vue/shared v3.5.44
+* @vue/shared v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -11633,15 +11633,15 @@ var init_shared_esm_bundler = __esmMin((() => {
 		});
 	};
 	camelizeRE = /-\w/g;
-	camelize = cacheStringFunction((str) => {
+	camelize = /* @__PURE__ */ cacheStringFunction((str) => {
 		return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
 	});
 	hyphenateRE = /\B([A-Z])/g;
-	hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-	capitalize = cacheStringFunction((str) => {
+	hyphenate = /* @__PURE__ */ cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+	capitalize = /* @__PURE__ */ cacheStringFunction((str) => {
 		return str.charAt(0).toUpperCase() + str.slice(1);
 	});
-	toHandlerKey = cacheStringFunction((str) => {
+	toHandlerKey = /* @__PURE__ */ cacheStringFunction((str) => {
 		return str ? `on${capitalize(str)}` : ``;
 	});
 	hasChanged = (value, oldValue) => !Object.is(value, oldValue);
@@ -11765,7 +11765,7 @@ var init_shared_esm_bundler = __esmMin((() => {
 	isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
 	isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
 	isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
-	specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly`;
+	specialBooleanAttrs = `itemscope,allowfullscreen,disablepictureinpicture,disableremoteplayback,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly`;
 	isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
 	isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
 	unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u000d\u0020]/;
@@ -11806,7 +11806,7 @@ var init_shared_esm_bundler = __esmMin((() => {
 }));
 // node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js
 /**
-* @vue/compiler-core v3.5.44
+* @vue/compiler-core v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -12516,7 +12516,11 @@ function getLoc(start, end) {
 	};
 }
 function cloneLoc(loc) {
-	return getLoc(loc.start.offset, loc.end.offset);
+	return {
+		start: extend({}, loc.start),
+		end: extend({}, loc.end),
+		source: loc.source
+	};
 }
 function setLocEnd(loc, end) {
 	loc.end = tokenizer.getPos(end);
@@ -16168,7 +16172,7 @@ var compiler_dom_esm_bundler_exports = /* @__PURE__ */ __exportAll({
 	warnDeprecation: () => warnDeprecation
 });
 /**
-* @vue/compiler-dom v3.5.44
+* @vue/compiler-dom v3.5.45
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -34373,6 +34377,33 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		MAX_SAFE_BUILD_LENGTH: 250,
 		MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 
 		/* istanbul ignore next */ 9007199254740991,
+		WHITESPACE_CHARACTERS: [
+			"	",
+			"\n",
+			"\v",
+			"\f",
+			"\r",
+			" ",
+			"\xA0",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			" ",
+			"\u2028",
+			"\u2029",
+			" ",
+			" ",
+			"　",
+			""
+		],
 		RELEASE_TYPES: [
 			"major",
 			"premajor",
@@ -34983,6 +35014,341 @@ var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 	module.exports = LRUCache;
 }));
+// node_modules/semver/internal/trim-comparator-whitespace.js
+var require_trim_comparator_whitespace = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { MAX_LENGTH, MAX_SAFE_BUILD_LENGTH, WHITESPACE_CHARACTERS } = require_constants();
+	/**
+	* Remembers the last two rows of digits so their characters need not be reread.
+	* Positions start at -1 until a row has been found.
+	*
+	* @typedef {object} DigitRunCache
+	* @property {number} start The first character of the most recently found row.
+	* @property {number} end The position after that row's last character.
+	* @property {number} previousStart The first character of the previous row.
+	* @property {number} previousEnd The position after the previous row.
+	*/
+	var whitespace = /* @__PURE__ */ new Uint8Array(65536);
+	for (const char of WHITESPACE_CHARACTERS) whitespace[char.charCodeAt(0)] = 1;
+	/**
+	* Checks whether a character is whitespace, like a space, tab, or newline.
+	* Looking past the end of the string returns false.
+	*
+	* @param {string|undefined} char One character, or undefined past the string's end.
+	* @returns {boolean} Whether the character is whitespace.
+	* @example isWhitespace(' ') // true
+	* @example isWhitespace('1') // false
+	*/
+	var isWhitespace = (char) => char !== void 0 && whitespace[char.charCodeAt(0)] === 1;
+	/**
+	* Checks for v, =, or whitespace before the version number.
+	* These are historical version prefixes, not range operators:
+	* < and > are handled separately, as are tilde and caret ranges.
+	*
+	* @param {string|undefined} char One character to check.
+	* @returns {boolean} Whether the character can belong to a version prefix.
+	* @example isVersionPrefix('=') // true
+	* @example isVersionPrefix('>') // false
+	*/
+	var isVersionPrefix = (char) => char === "v" || char === "=" || isWhitespace(char);
+	/**
+	* Checks whether a character is one of the digits 0 through 9.
+	*
+	* @param {string|undefined} char One character to check.
+	* @returns {boolean} Whether the character is an ASCII digit.
+	* @example isDigit('7') // true
+	* @example isDigit('.') // false
+	*/
+	var isDigit = (char) => char !== void 0 && char >= "0" && char <= "9";
+	/**
+	* Checks whether a character is an English letter, uppercase or lowercase.
+	*
+	* @param {string|undefined} char One character to check.
+	* @returns {boolean} Whether the character is an ASCII letter.
+	* @example isLetter('b') // true
+	* @example isLetter('7') // false
+	*/
+	var isLetter = (char) => char !== void 0 && (char >= "a" && char <= "z" || char >= "A" && char <= "Z");
+	/**
+	* Checks for a letter, digit, or hyphen: the characters allowed inside
+	* prerelease and build names such as beta-1.
+	*
+	* @param {string|undefined} char One character to check.
+	* @returns {boolean} Whether the character can be part of an identifier.
+	* @example isIdentifierCharacter('-') // true
+	* @example isIdentifierCharacter('.') // false; dots separate identifiers
+	*/
+	var isIdentifierCharacter = (char) => isDigit(char) || isLetter(char) || char === "-";
+	/**
+	* Checks whether a version component can begin here: with a digit or
+	* a wildcard such as x, X, or *.
+	*
+	* @param {string|undefined} char One character to check.
+	* @returns {boolean} Whether a number or wildcard can start with this character.
+	* @example isVersionStart('x') // true
+	* @example isVersionStart('v') // false; v belongs to the prefix
+	*/
+	var isVersionStart = (char) => isDigit(char) || char === "x" || char === "X" || char === "*";
+	/**
+	* Finds the end of a row of digits, but returns no more than limit digits.
+	* Remembers the last two rows so looking at them again does not reread them.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position of the first character to check.
+	* @param {number} limit The most digit characters the returned match can include.
+	* @param {DigitRunCache} digitRuns Shared cache of digit-run positions, updated in place.
+	* @returns {number} The position after the matched digits, or start if none match.
+	* @example findDigitsEndIndex('123abc', 0, 10, digitRuns) // 3, pointing at a
+	* @example findDigitsEndIndex('123abc', 0, 2, digitRuns) // 2, pointing at the unread 3
+	*/
+	var findDigitsEndIndex = (range, start, limit, digitRuns) => {
+		if (!isDigit(range[start])) return start;
+		if (start >= digitRuns.start && start < digitRuns.end) return Math.min(start + limit, digitRuns.end);
+		if (start >= digitRuns.previousStart && start < digitRuns.previousEnd) return Math.min(start + limit, digitRuns.previousEnd);
+		let end = start + 1;
+		while (isDigit(range[end])) end++;
+		digitRuns.previousStart = digitRuns.start;
+		digitRuns.previousEnd = digitRuns.end;
+		digitRuns.start = start;
+		digitRuns.end = end;
+		return Math.min(start + limit, end);
+	};
+	/**
+	* Reads a number using the old regex's length and leading-zero rules.
+	* Strict mode reads just the first zero in 012; loose mode can read all three.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the number should begin.
+	* @param {boolean} loose Whether to allow leading zeros.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the matched digits, not their numeric value.
+	* @example findVersionNumberEndIndex('012', 0, false, digitRuns) // 1
+	* @example findVersionNumberEndIndex('012', 0, true, digitRuns) // 3
+	*/
+	var findVersionNumberEndIndex = (range, start, loose, digitRuns) => {
+		if (!loose && range[start] === "0") return start + 1;
+		return findDigitsEndIndex(range, start, loose ? MAX_LENGTH : MAX_LENGTH + 1, digitRuns);
+	};
+	/**
+	* Reads one piece of a prerelease name, such as beta or 1 in beta.1.
+	* Tries the letter-or-hyphen form first, then the number-only form.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the identifier should begin.
+	* @param {boolean} loose Whether numeric identifiers may have leading zeros.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the identifier, or start if none matches.
+	* @example findPrereleaseIdentifierEndIndex('beta.1', 0, false, digitRuns) // 4, at the dot
+	* @example findPrereleaseIdentifierEndIndex('001beta', 0, false, digitRuns) // 7
+	*/
+	var findPrereleaseIdentifierEndIndex = (range, start, loose, digitRuns) => {
+		const digitsEnd = findDigitsEndIndex(range, start, MAX_LENGTH, digitRuns);
+		if (isLetter(range[digitsEnd]) || range[digitsEnd] === "-") {
+			let end = digitsEnd + 1;
+			const limit = end + MAX_SAFE_BUILD_LENGTH;
+			while (end < limit && isIdentifierCharacter(range[end])) end++;
+			return end;
+		}
+		return findVersionNumberEndIndex(range, start, loose, digitRuns);
+	};
+	/**
+	* Reads a prerelease suffix such as -beta.1, one dot-separated piece at a time.
+	* Loose mode also allows the name without its opening hyphen.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the suffix should begin, including -.
+	* @param {boolean} loose Whether the opening hyphen is optional and zeros allowed.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the matched suffix, or start if absent.
+	* @example findPrereleaseEndIndex('-beta.1+sha', 0, false, digitRuns) // 7, at the plus
+	* @example findPrereleaseEndIndex('beta', 0, false, digitRuns) // 0; no opening hyphen
+	*/
+	var findPrereleaseEndIndex = (range, start, loose, digitRuns) => {
+		const hyphen = range[start] === "-";
+		if (!loose && !hyphen) return start;
+		const identifierStart = start + (hyphen ? 1 : 0);
+		let end = findPrereleaseIdentifierEndIndex(range, identifierStart, loose, digitRuns);
+		if (end === identifierStart) {
+			if (!loose || !hyphen) return start;
+			end = findPrereleaseIdentifierEndIndex(range, start, loose, digitRuns);
+		}
+		while (range[end] === ".") {
+			const next = findPrereleaseIdentifierEndIndex(range, end + 1, loose, digitRuns);
+			if (next === end + 1) break;
+			end = next;
+		}
+		return end;
+	};
+	/**
+	* Reads one build-name piece, such as sha or 123 in +sha.123.
+	* Stops at a disallowed character or the old regex's length limit.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the identifier should begin.
+	* @returns {number} The position after the identifier, or start if none matches.
+	* @example findBuildIdentifierEndIndex('sha.123', 0) // 3, at the dot
+	* @example findBuildIdentifierEndIndex('001', 0) // 3; leading zeros are allowed
+	*/
+	var findBuildIdentifierEndIndex = (range, start) => {
+		let end = start;
+		while (end - start < MAX_SAFE_BUILD_LENGTH && isIdentifierCharacter(range[end])) end++;
+		return end;
+	};
+	/**
+	* Reads optional build metadata such as +sha.123.
+	* Leaves the position unchanged if there is no plus sign followed by a name.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the opening + should be.
+	* @returns {number} The position after the matched metadata, or start if absent.
+	* @example findBuildEndIndex('+sha.123 <2', 0) // 8, at the space
+	* @example findBuildEndIndex('+', 0) // 0; a plus sign alone is not a match
+	*/
+	var findBuildEndIndex = (range, start) => {
+		if (range[start] !== "+") return start;
+		let end = findBuildIdentifierEndIndex(range, start + 1);
+		if (end === start + 1) return start;
+		while (range[end] === ".") {
+			const next = findBuildIdentifierEndIndex(range, end + 1);
+			if (next === end + 1) break;
+			end = next;
+		}
+		return end;
+	};
+	/**
+	* Reads three numbers separated by dots, then any prerelease and build suffixes.
+	* Uses loose rules, so forms such as 01.02.03beta can match here.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position of the first number, after any prefix.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the version match, or start if none matches.
+	* @example findLooseFullVersionEndIndex('1.2.3-beta+sha <2', 0, digitRuns) // 14
+	* @example findLooseFullVersionEndIndex('1.2', 0, digitRuns) // 0; needs three numbers
+	*/
+	var findLooseFullVersionEndIndex = (range, start, digitRuns) => {
+		let end = start;
+		for (let component = 0; component < 3; component++) {
+			const next = findVersionNumberEndIndex(range, end, true, digitRuns);
+			if (next === end) return start;
+			end = next;
+			if (component < 2) {
+				if (range[end] !== ".") return start;
+				end++;
+			}
+		}
+		return findBuildEndIndex(range, findPrereleaseEndIndex(range, end, true, digitRuns));
+	};
+	/**
+	* Reads one component of a partial or wildcard version, such as 2 or x in 2.x.
+	* Numbers use strict leading-zero rules; wildcards take up one character.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position where the component should begin.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the component, or start if none matches.
+	* @example findPartialVersionComponentEndIndex('2.x', 0, digitRuns) // 1, at the dot
+	* @example findPartialVersionComponentEndIndex('2.x', 2, digitRuns) // 3, after x
+	*/
+	var findPartialVersionComponentEndIndex = (range, start, digitRuns) => {
+		if (isDigit(range[start])) return findVersionNumberEndIndex(range, start, false, digitRuns);
+		return isVersionStart(range[start]) ? start + 1 : start;
+	};
+	/**
+	* Reads up to three components, allowing forms such as 1, 1.2, or 1.x.
+	* After the third component, also reads any strict prerelease and build suffixes.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position of a number or wildcard, after any prefix.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position after the matched version text.
+	* @example findPartialVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space
+	* @example findPartialVersionEndIndex('1.', 0, digitRuns) // 1; the trailing dot is unread
+	*/
+	var findPartialVersionEndIndex = (range, start, digitRuns) => {
+		let end = findPartialVersionComponentEndIndex(range, start, digitRuns);
+		for (let component = 0; component < 2; component++) {
+			if (range[end] !== ".") return end;
+			const next = findPartialVersionComponentEndIndex(range, end + 1, digitRuns);
+			if (next === end + 1) return end;
+			end = next;
+		}
+		return findBuildEndIndex(range, findPrereleaseEndIndex(range, end, false, digitRuns));
+	};
+	/**
+	* Finds where a version match ends, without deciding whether the range is valid.
+	* Tries a loose full version first, then a partial or wildcard version, just
+	* like the old regex's LOOSEPLAIN and XRANGEPLAIN alternatives.
+	*
+	* @param {string} range The text to read; it is not changed.
+	* @param {number} start The position of a number or wildcard, after any prefix.
+	* @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+	* @returns {number} The position where scanning the next candidate can resume.
+	* @example findVersionEndIndex('1.2.3 <2', 0, digitRuns) // 5, at the space
+	* @example findVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space
+	*/
+	var findVersionEndIndex = (range, start, digitRuns) => {
+		const fullVersionEnd = findLooseFullVersionEndIndex(range, start, digitRuns);
+		return fullVersionEnd !== start ? fullVersionEnd : findPartialVersionEndIndex(range, start, digitRuns);
+	};
+	/**
+	* Finds the one whitespace character the old replacement would remove.
+	* Keeps leading whitespace, skips an optional operator, and checks immediately
+	* after it. Returns -1 if there is nothing to remove.
+	*
+	* @param {string} range The text containing a candidate already found by the caller.
+	* @param {number} matchStart The candidate's position, including leading whitespace.
+	* @returns {number} The position of the removable whitespace, or -1 if absent.
+	* @example findRemovableWhitespaceIndex(' > 1', 0) // 2; keep the space at position 0
+	* @example findRemovableWhitespaceIndex('>1', 0) // -1
+	*/
+	var findRemovableWhitespaceIndex = (range, matchStart) => {
+		let position = matchStart;
+		if (isWhitespace(range[position])) position++;
+		if (range[position] === "<" || range[position] === ">") position++;
+		if (range[position] === "=") position++;
+		return isWhitespace(range[position]) ? position : -1;
+	};
+	/**
+	* Joins an operator to its version, turning > 1.2.3 into >1.2.3.
+	* Copies everything else according to the old regex's matching rules.
+	* Moves forward through prefixes and whole versions to avoid repeatedly
+	* searching the same characters on long inputs.
+	*
+	* @param {string} range The range text to process; the original string is unchanged.
+	* @returns {string} The range with matched operator whitespace removed.
+	* @example trimComparatorWhitespace('> 1.2.3 < 2') // '>1.2.3 <2'
+	* @example trimComparatorWhitespace('> invalid') // '> invalid'
+	*/
+	var trimComparatorWhitespace = (range) => {
+		let result = "";
+		let copyFrom = 0;
+		let cursor = 0;
+		const digitRuns = {
+			start: -1,
+			end: -1,
+			previousStart: -1,
+			previousEnd: -1
+		};
+		while (cursor < range.length) {
+			const matchStart = cursor;
+			if (range[cursor] === "<" || range[cursor] === ">") cursor++;
+			else if (!isVersionPrefix(range[cursor]) && !isVersionStart(range[cursor])) {
+				cursor++;
+				continue;
+			}
+			while (cursor < range.length && isVersionPrefix(range[cursor])) cursor++;
+			if (!isVersionStart(range[cursor])) continue;
+			const whitespacePosition = findRemovableWhitespaceIndex(range, matchStart);
+			if (whitespacePosition !== -1) {
+				result += range.slice(copyFrom, whitespacePosition);
+				copyFrom = whitespacePosition + 1;
+			}
+			cursor = findVersionEndIndex(range, cursor, digitRuns);
+		}
+		return result + range.slice(copyFrom);
+	};
+	module.exports = trimComparatorWhitespace;
+}));
 // node_modules/semver/classes/range.js
 var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var SPACE_CHARACTERS = /\s+/g;
@@ -35047,7 +35413,7 @@ var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
 			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
 			debug("hyphen replace", range);
-			range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+			range = trimComparatorWhitespace(range);
 			debug("comparator trim", range);
 			range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
 			debug("tilde trim", range);
@@ -35098,7 +35464,8 @@ var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var Comparator = require_comparator();
 	var debug = require_debug();
 	var SemVer = require_semver$1();
-	var { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+	var trimComparatorWhitespace = require_trim_comparator_whitespace();
+	var { safeRe: re, src, t, tildeTrimReplace, caretTrimReplace } = require_re();
 	var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
 	var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
 	var isNullSet = (c) => c.value === "<0.0.0-0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package",
   "name": "@skaldapp/monaco-sfc",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "A Monaco Editor language server for Vue Single File Components (SFC) providing syntax highlighting, IntelliSense, error detection, and more",
   "keywords": [
     "vue",
@@ -65,12 +65,12 @@
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.3",
-    "@skaldapp/configs": "^1.7.14",
+    "@skaldapp/configs": "^1.7.16",
     "@types/markdown-it": "^14.2.0",
     "@types/node": "^26.6.6",
     "eslint": "^10.14.0",
     "jsonc-parser": "^3.3.1",
     "path-browserify": "^1.0.1",
-    "vite": "^8.3.5"
+    "vite": "^8.3.6"
   }
 }