astro-eslint-parser 2.1.0 → 3.0.0

package/lib/index.mjs

@@ -11,8 +11,7 @@ import semver, { satisfies } from "semver";
 import { globSync, isDynamicPattern } from "tinyglobby";
 import { Reference, Variable, analyze } from "@typescript-eslint/scope-manager";
 import * as eslintScope$1 from "eslint-scope";
-import { DecodingMode, EntityDecoder, htmlDecodeTree } from "entities/decode";
-import * as service from "astrojs-compiler-sync";
+import { parse } from "@astrojs/compiler-rs";
 const KEYS = unionWith({
 	Program: ["body"],
 	AstroFragment: ["children"],
@@ -62,13 +61,15 @@ function getTSProgram(code, options, ts) {
 	return service.getProgram(code, options.filePath);
 }
 var TSService = class {
+	watch;
+	patchedHostSet = /* @__PURE__ */ new WeakSet();
+	currTarget = {
+		code: "",
+		filePath: ""
+	};
+	fileWatchCallbacks = /* @__PURE__ */ new Map();
+	ts;
 	constructor(tsconfigPath, ts) {
-		this.patchedHostSet = /* @__PURE__ */ new WeakSet();
-		this.currTarget = {
-			code: "",
-			filePath: ""
-		};
-		this.fileWatchCallbacks = /* @__PURE__ */ new Map();
 		this.ts = ts;
 		this.watch = this.createWatch(tsconfigPath);
 	}
@@ -394,15 +395,15 @@ function getKeys(node, visitorKeys) {
 function* getNodes(node, key) {
 	const child = node[key];
 	if (Array.isArray(child)) {
-		for (const c of child) if (isNode(c)) yield c;
-	} else if (isNode(child)) yield child;
+		for (const c of child) if (isNode$1(c)) yield c;
+	} else if (isNode$1(child)) yield child;
 }
 /**
 * Check whether a given value is a node.
 * @param x The value to check.
 * @returns `true` if the value is a node.
 */
-function isNode(x) {
+function isNode$1(x) {
 	return x !== null && typeof x === "object" && typeof x.type === "string";
 }
 /**
@@ -426,248 +427,6 @@ function traverseNodes(node, visitor) {
 	traverse(node, null, visitor);
 }
 //#endregion
-//#region src/util/index.ts
-/**
-* Uses a binary search to determine the highest index at which value should be inserted into array in order to maintain its sort order.
-*/
-function sortedLastIndex(array, compare) {
-	let lower = 0;
-	let upper = array.length;
-	while (lower < upper) {
-		const mid = Math.floor(lower + (upper - lower) / 2);
-		const target = compare(array[mid]);
-		if (target < 0) lower = mid + 1;
-		else if (target > 0) upper = mid;
-		else return mid + 1;
-	}
-	return upper;
-}
-/**
-* Add element to a sorted array
-*/
-function addElementToSortedArray(array, element, compare) {
-	const index = sortedLastIndex(array, (target) => compare(target, element));
-	array.splice(index, 0, element);
-}
-/**
-* Add element to a sorted array
-*/
-function addElementsToSortedArray(array, elements, compare) {
-	if (!elements.length) return;
-	let last = elements[0];
-	let index = sortedLastIndex(array, (target) => compare(target, last));
-	for (const element of elements) {
-		if (compare(last, element) > 0) index = sortedLastIndex(array, (target) => compare(target, element));
-		let e = array[index];
-		while (e && compare(e, element) <= 0) e = array[++index];
-		array.splice(index, 0, element);
-		last = element;
-	}
-}
-const WRITE_FLAG = 2;
-const READ_WRITE_FLAG = 3;
-const REFERENCE_TYPE_TYPE_FLAG = 2;
-/**
-* Gets the scope for the Program node
-*/
-function getProgramScope(scopeManager) {
-	const globalScope = scopeManager.globalScope;
-	return globalScope.childScopes.find((s) => s.type === "module") || globalScope;
-}
-/** Remove all scope, variable, and reference */
-function removeAllScopeAndVariableAndReference(target, info) {
-	const removeTargetScopes = /* @__PURE__ */ new Set();
-	traverseNodes(target, {
-		visitorKeys: info.visitorKeys,
-		enterNode(node) {
-			const scope = info.scopeManager.acquire(node);
-			if (scope) {
-				removeTargetScopes.add(scope);
-				return;
-			}
-			if (node.type === "Identifier" || node.type === "JSXIdentifier") {
-				let targetScope = getInnermostScopeFromNode(info.scopeManager, node);
-				while (targetScope && targetScope.block.type !== "Program" && target.range[0] <= targetScope.block.range[0] && targetScope.block.range[1] <= target.range[1]) targetScope = targetScope.upper;
-				if (removeTargetScopes.has(targetScope)) return;
-				removeIdentifierVariable(node, targetScope);
-				removeIdentifierReference(node, targetScope);
-			}
-		},
-		leaveNode() {}
-	});
-	for (const scope of removeTargetScopes) removeScope(info.scopeManager, scope);
-}
-/**
-* Add the virtual reference.
-*/
-function addVirtualReference(node, variable, scope, status) {
-	const reference = new Reference(node, scope, status.write && status.read ? READ_WRITE_FLAG : status.write ? WRITE_FLAG : 1, void 0, void 0, void 0, status.typeRef ? REFERENCE_TYPE_TYPE_FLAG : 1);
-	reference.astroVirtualReference = true;
-	addReference(variable.references, reference);
-	reference.resolved = variable;
-	if (status.forceUsed) variable.eslintUsed = true;
-	return reference;
-}
-/**
-* Add global variable
-*/
-function addGlobalVariable(reference, scopeManager) {
-	const globalScope = scopeManager.globalScope;
-	const name = reference.identifier.name;
-	let variable = globalScope.set.get(name);
-	if (!variable) {
-		variable = new Variable(name, globalScope);
-		globalScope.variables.push(variable);
-		globalScope.set.set(name, variable);
-	}
-	reference.resolved = variable;
-	variable.references.push(reference);
-	return variable;
-}
-/** Remove reference from through */
-function removeReferenceFromThrough(reference, baseScope) {
-	const variable = reference.resolved;
-	const name = reference.identifier.name;
-	let scope = baseScope;
-	while (scope) {
-		for (const ref of [...scope.through]) if (reference === ref) scope.through.splice(scope.through.indexOf(ref), 1);
-		else if (ref.identifier.name === name) {
-			ref.resolved = variable;
-			if (!variable.references.includes(ref)) addReference(variable.references, ref);
-			scope.through.splice(scope.through.indexOf(ref), 1);
-		}
-		scope = scope.upper;
-	}
-}
-/** Remove scope */
-function removeScope(scopeManager, scope) {
-	for (const childScope of scope.childScopes) removeScope(scopeManager, childScope);
-	while (scope.references[0]) removeReference(scope.references[0], scope);
-	const upper = scope.upper;
-	if (upper) {
-		const index = upper.childScopes.indexOf(scope);
-		if (index >= 0) upper.childScopes.splice(index, 1);
-	}
-	const index = scopeManager.scopes.indexOf(scope);
-	if (index >= 0) scopeManager.scopes.splice(index, 1);
-}
-/** Remove reference */
-function removeReference(reference, baseScope) {
-	if (reference.resolved) if (reference.resolved.defs.some((d) => d.name === reference.identifier)) {
-		const varIndex = baseScope.variables.indexOf(reference.resolved);
-		if (varIndex >= 0) baseScope.variables.splice(varIndex, 1);
-		const name = reference.identifier.name;
-		if (reference.resolved === baseScope.set.get(name)) baseScope.set.delete(name);
-	} else {
-		const refIndex = reference.resolved.references.indexOf(reference);
-		if (refIndex >= 0) reference.resolved.references.splice(refIndex, 1);
-	}
-	let scope = baseScope;
-	while (scope) {
-		const refIndex = scope.references.indexOf(reference);
-		if (refIndex >= 0) scope.references.splice(refIndex, 1);
-		const throughIndex = scope.through.indexOf(reference);
-		if (throughIndex >= 0) scope.through.splice(throughIndex, 1);
-		scope = scope.upper;
-	}
-}
-/** Remove variable */
-function removeIdentifierVariable(node, scope) {
-	for (let varIndex = 0; varIndex < scope.variables.length; varIndex++) {
-		const variable = scope.variables[varIndex];
-		const defIndex = variable.defs.findIndex((def) => def.name === node);
-		if (defIndex < 0) continue;
-		variable.defs.splice(defIndex, 1);
-		if (variable.defs.length === 0) {
-			referencesToThrough(variable.references, scope);
-			variable.references.forEach((r) => {
-				if (r.init) r.init = false;
-				r.resolved = null;
-			});
-			scope.variables.splice(varIndex, 1);
-			const name = node.name;
-			if (variable === scope.set.get(name)) scope.set.delete(name);
-		} else {
-			const idIndex = variable.identifiers.indexOf(node);
-			if (idIndex >= 0) variable.identifiers.splice(idIndex, 1);
-		}
-		return;
-	}
-}
-/** Remove reference */
-function removeIdentifierReference(node, scope) {
-	const reference = scope.references.find((ref) => ref.identifier === node);
-	if (reference) {
-		removeReference(reference, scope);
-		return true;
-	}
-	const location = node.range[0];
-	const pendingScopes = [];
-	for (const childScope of scope.childScopes) {
-		const range = childScope.block.range;
-		if (range[0] <= location && location < range[1]) {
-			if (removeIdentifierReference(node, childScope)) return true;
-		} else pendingScopes.push(childScope);
-	}
-	for (const childScope of pendingScopes) if (removeIdentifierReference(node, childScope)) return true;
-	return false;
-}
-/**
-* Get the innermost scope which contains a given node.
-* @returns The innermost scope.
-*/
-function getInnermostScopeFromNode(scopeManager, currentNode) {
-	return getInnermostScope(getScopeFromNode(scopeManager, currentNode), currentNode);
-}
-/**
-* Gets the scope for the current node
-*/
-function getScopeFromNode(scopeManager, currentNode) {
-	let node = currentNode;
-	for (; node; node = node.parent || null) {
-		const scope = scopeManager.acquire(node, false);
-		if (scope) {
-			if (scope.type === "function-expression-name") return scope.childScopes[0];
-			if (scope.type === "global" && node.type === "Program" && node.sourceType === "module") return scope.childScopes.find((s) => s.type === "module") || scope;
-			return scope;
-		}
-	}
-	return scopeManager.globalScope;
-}
-/**
-* Get the innermost scope which contains a given location.
-* @param initialScope The initial scope to search.
-* @param node The location to search.
-* @returns The innermost scope.
-*/
-function getInnermostScope(initialScope, node) {
-	for (const childScope of initialScope.childScopes) {
-		const range = childScope.block.range;
-		if (range[0] <= node.range[0] && node.range[1] <= range[1]) return getInnermostScope(childScope, node);
-	}
-	return initialScope;
-}
-/** Move reference to through */
-function referencesToThrough(references, baseScope) {
-	let scope = baseScope;
-	while (scope) {
-		addAllReferences(scope.through, references);
-		scope = scope.upper;
-	}
-}
-/**
-* Add all references to array
-*/
-function addAllReferences(list, elements) {
-	addElementsToSortedArray(list, elements, (a, b) => a.identifier.range[0] - b.identifier.range[0]);
-}
-/**
-* Add reference to array
-*/
-function addReference(list, reference) {
-	addElementToSortedArray(list, reference, (a, b) => a.identifier.range[0] - b.identifier.range[0]);
-}
-//#endregion
 //#region src/parser/eslint-scope.ts
 let eslintScopeCache = null;
 /**
@@ -774,31 +533,6 @@ ${code}`);
 		patchResult?.terminate();
 	}
 }
-var Referencer = class extends eslintScope.Referencer {
-	JSXAttribute(node) {
-		this.visit(node.value);
-	}
-	JSXClosingElement() {}
-	JSXFragment(node) {
-		this.visitChildren(node);
-	}
-	JSXIdentifier(node) {
-		const scope = this.currentScope();
-		const ref = new Reference(node, scope, 1, void 0, void 0, false, 1);
-		scope.references.push(ref);
-		scope.__left.push(ref);
-	}
-	JSXMemberExpression(node) {
-		if (node.object.type !== AST_NODE_TYPES.JSXIdentifier) this.visit(node.object);
-		else if (node.object.name !== "this") this.visit(node.object);
-	}
-	JSXOpeningElement(node) {
-		if (node.name.type === AST_NODE_TYPES.JSXIdentifier) {
-			if (node.name.name[0].toUpperCase() === node.name.name[0] || node.name.name === "this") this.visit(node.name);
-		} else this.visit(node.name);
-		for (const attr of node.attributes) this.visit(attr);
-	}
-};
 /**
 * Analyzed scopes for JavaScript.
 */
@@ -810,11 +544,10 @@ function analyzeForEcmaScript(tree, providedOptions) {
 		sourceType: "script",
 		ecmaVersion: 5,
 		childVisitorKeys: null,
-		fallback: "iteration"
+		fallback: "iteration",
+		jsx: true
 	}, providedOptions);
-	const scopeManager = new eslintScope.ScopeManager(options);
-	new Referencer(options, scopeManager).visit(tree);
-	return scopeManager;
+	return eslintScope.analyze(tree, options);
 }
 //#endregion
 //#region src/parser/sort.ts
@@ -828,403 +561,12 @@ function sort(tokens) {
 	});
 }
 //#endregion
-//#region src/errors.ts
-/**
-* Astro parse errors.
-*/
-var ParseError = class extends SyntaxError {
-	/**
-	* Initialize this ParseError instance.
-	*/
-	constructor(message, offset, ctx) {
-		super(message);
-		if (typeof offset === "number") {
-			this.index = offset;
-			const loc = ctx.getLocFromIndex(offset);
-			this.lineNumber = loc.line;
-			this.column = loc.column;
-		} else {
-			this.index = ctx.getIndexFromLoc(offset);
-			this.lineNumber = offset.line;
-			this.column = offset.column;
-		}
-		this.originalAST = ctx.originalAST;
-	}
-};
-//#endregion
-//#region src/astro/index.ts
-/**
-* Checks if the given node is TagLikeNode
-*/
-function isTag(node) {
-	return node.type === "element" || node.type === "custom-element" || node.type === "component" || node.type === "fragment";
-}
-/**
-* Checks if the given node is ParentNode
-*/
-function isParent(node) {
-	return Array.isArray(node.children);
-}
-/** walk element nodes */
-function walkElements(parent, code, enter, leave, parents = []) {
-	const children = getSortedChildren(parent, code);
-	const currParents = [parent, ...parents];
-	for (const node of children) {
-		enter(node, currParents);
-		if (isParent(node)) walkElements(node, code, enter, leave, currParents);
-		leave(node, currParents);
-	}
-}
-/** walk nodes */
-function walk(parent, code, enter, leave) {
-	walkElements(parent, code, (node, parents) => {
-		enter(node, parents);
-		if (isTag(node)) {
-			const attrParents = [node, ...parents];
-			for (const attr of node.attributes) {
-				enter(attr, attrParents);
-				leave(attr, attrParents);
-			}
-		}
-	}, leave);
-}
-/**
-* Get end offset of start tag
-*/
-function calcStartTagEndOffset(node, ctx) {
-	const lastAttr = node.attributes[node.attributes.length - 1];
-	let beforeCloseIndex;
-	if (lastAttr) beforeCloseIndex = calcAttributeEndOffset(lastAttr, ctx);
-	else {
-		const info = getTokenInfo(ctx, [`<${node.name}`], node.position.start.offset);
-		beforeCloseIndex = info.index + info.match.length;
-	}
-	const info = getTokenInfo(ctx, [[">", "/>"]], beforeCloseIndex);
-	return info.index + info.match.length;
-}
-/**
-* Get end offset of attribute
-*/
-function calcAttributeEndOffset(node, ctx) {
-	let info;
-	if (node.kind === "empty") info = getTokenInfo(ctx, [node.name], node.position.start.offset);
-	else if (node.kind === "quoted") info = getTokenInfo(ctx, [[
-		{
-			token: `"${node.value}"`,
-			htmlEntityDecode: true
-		},
-		{
-			token: `'${node.value}'`,
-			htmlEntityDecode: true
-		},
-		{
-			token: node.value,
-			htmlEntityDecode: true
-		}
-	]], calcAttributeValueStartOffset(node, ctx));
-	else if (node.kind === "expression") info = getTokenInfo(ctx, [
-		"{",
-		node.value,
-		"}"
-	], calcAttributeValueStartOffset(node, ctx));
-	else if (node.kind === "shorthand") info = getTokenInfo(ctx, [
-		"{",
-		node.name,
-		"}"
-	], node.position.start.offset);
-	else if (node.kind === "spread") info = getTokenInfo(ctx, [
-		"{",
-		"...",
-		node.name,
-		"}"
-	], node.position.start.offset);
-	else if (node.kind === "template-literal") info = getTokenInfo(ctx, [`\`${node.value}\``], calcAttributeValueStartOffset(node, ctx));
-	else throw new ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
-	return info.index + info.match.length;
-}
-/**
-* Get start offset of attribute value
-*/
-function calcAttributeValueStartOffset(node, ctx) {
-	let info;
-	if (node.kind === "quoted") info = getTokenInfo(ctx, [
-		node.name,
-		"=",
-		[
-			`"`,
-			`'`,
-			{
-				token: node.value,
-				htmlEntityDecode: true
-			}
-		]
-	], node.position.start.offset);
-	else if (node.kind === "expression") info = getTokenInfo(ctx, [
-		node.name,
-		"=",
-		"{"
-	], node.position.start.offset);
-	else if (node.kind === "template-literal") info = getTokenInfo(ctx, [
-		node.name,
-		"=",
-		"`"
-	], node.position.start.offset);
-	else throw new ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
-	return info.index;
-}
-/**
-* Get end offset of tag
-*/
-function getEndOffset(node, ctx) {
-	if (node.position.end?.offset != null) return node.position.end.offset;
-	if (isTag(node)) return calcTagEndOffset(node, ctx);
-	if (node.type === "expression") return calcExpressionEndOffset(node, ctx);
-	if (node.type === "comment") return calcCommentEndOffset(node, ctx);
-	if (node.type === "frontmatter") {
-		const start = node.position.start.offset;
-		return ctx.code.indexOf("---", start + 3) + 3;
-	}
-	if (node.type === "doctype") {
-		const start = node.position.start.offset;
-		return ctx.code.indexOf(">", start) + 1;
-	}
-	if (node.type === "text") return node.position.start.offset + node.value.length;
-	if (node.type === "root") return ctx.code.length;
-	throw new Error(`unknown type: ${node.type}`);
-}
-/**
-* Get content end offset
-*/
-function calcContentEndOffset(parent, ctx) {
-	const code = ctx.code;
-	if (isTag(parent)) {
-		const end = getEndOffset(parent, ctx);
-		if (code[end - 1] !== ">") return end;
-		const index = code.lastIndexOf("</", end - 1);
-		if (index >= 0 && code.slice(index + 2, end - 1).trim() === parent.name) return index;
-		return end;
-	} else if (parent.type === "expression") {
-		const end = getEndOffset(parent, ctx);
-		return code.lastIndexOf("}", end);
-	} else if (parent.type === "root") return code.length;
-	throw new Error(`unknown type: ${parent.type}`);
-}
-/**
-* If the given tag is a self-close tag, get the self-closing tag.
-*/
-function getSelfClosingTag(node, ctx) {
-	if (node.children.length > 0) return null;
-	const code = ctx.code;
-	const startTagEndOffset = calcStartTagEndOffset(node, ctx);
-	if (code.startsWith("/>", startTagEndOffset - 2)) return {
-		offset: startTagEndOffset,
-		end: "/>"
-	};
-	if (code.startsWith(`</${node.name}`, startTagEndOffset)) return null;
-	return {
-		offset: startTagEndOffset,
-		end: ">"
-	};
-}
-/**
-* If the given tag has a end tag, get the end tag.
-*/
-function getEndTag(node, ctx) {
-	let beforeIndex;
-	if (node.children.length) {
-		const lastChild = node.children[node.children.length - 1];
-		beforeIndex = getEndOffset(lastChild, ctx);
-	} else beforeIndex = calcStartTagEndOffset(node, ctx);
-	beforeIndex = skipSpaces(ctx.code, beforeIndex);
-	if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-		const offset = beforeIndex;
-		beforeIndex = beforeIndex + 2 + node.name.length;
-		const info = getTokenInfo(ctx, [">"], beforeIndex);
-		const end = info.index + info.match.length;
-		return {
-			offset,
-			tag: ctx.code.slice(offset, end)
-		};
-	}
-	return null;
-}
-/**
-* Get end offset of comment
-*/
-function calcCommentEndOffset(node, ctx) {
-	const info = getTokenInfo(ctx, [
-		"<!--",
-		node.value,
-		"-->"
-	], node.position.start.offset);
-	return info.index + info.match.length;
-}
-/**
-* Get end offset of tag
-*/
-function calcTagEndOffset(node, ctx) {
-	let beforeIndex;
-	if (node.children.length) {
-		const lastChild = node.children[node.children.length - 1];
-		beforeIndex = getEndOffset(lastChild, ctx);
-	} else beforeIndex = calcStartTagEndOffset(node, ctx);
-	beforeIndex = skipSpaces(ctx.code, beforeIndex);
-	if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-		beforeIndex = beforeIndex + 2 + node.name.length;
-		const info = getTokenInfo(ctx, [">"], beforeIndex);
-		return info.index + info.match.length;
-	}
-	return beforeIndex;
-}
-/**
-* Get end offset of Expression
-*/
-function calcExpressionEndOffset(node, ctx) {
-	if (node.children.length) {
-		const lastChild = node.children[node.children.length - 1];
-		const info = getTokenInfo(ctx, ["}"], getEndOffset(lastChild, ctx));
-		return info.index + info.match.length;
-	}
-	const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
-	return info.index + info.match.length;
-}
-/**
-* Get token info
-*/
-function getTokenInfo(ctx, tokens, position) {
-	let lastMatch;
-	for (const t of tokens) {
-		const index = lastMatch ? lastMatch.index + lastMatch.match.length : position;
-		const m = Array.isArray(t) ? matchOfForMulti(t, index) : match(t, index);
-		if (m == null) throw new ParseError(`Unknown token at ${index}, expected: ${JSON.stringify(t)}, actual: ${JSON.stringify(ctx.code.slice(index, index + 10))}`, index, ctx);
-		lastMatch = m;
-	}
-	return lastMatch;
-	/**
-	* For Single Token
-	*/
-	function match(token, position) {
-		const search = typeof token === "string" ? token : token.token;
-		const index = search.trim() === search ? skipSpaces(ctx.code, position) : position;
-		if (ctx.code.startsWith(search, index)) return {
-			match: search,
-			index
-		};
-		if (typeof token !== "string") return matchWithHTMLEntity(token, index);
-		return null;
-	}
-	/**
-	* For Multiple Token
-	*/
-	function matchOfForMulti(search, position) {
-		for (const s of search) {
-			const m = match(s, position);
-			if (m) return m;
-		}
-		return null;
-	}
-	/**
-	* With HTML entity
-	*/
-	function matchWithHTMLEntity(token, position) {
-		const search = token.token;
-		let codeOffset = position;
-		let searchOffset = 0;
-		while (searchOffset < search.length) {
-			const searchChar = search[searchOffset];
-			if (ctx.code[codeOffset] === searchChar) {
-				if (searchChar === "&") {
-					const entityCandidate = ctx.code.slice(codeOffset, codeOffset + 5);
-					if (entityCandidate === "&amp;" || entityCandidate === "&AMP;") {
-						codeOffset += 5;
-						searchOffset++;
-						continue;
-					}
-				}
-				codeOffset++;
-				searchOffset++;
-				continue;
-			}
-			const entity = getHTMLEntity(codeOffset);
-			if (entity?.entity === searchChar) {
-				codeOffset += entity.length;
-				searchOffset++;
-				continue;
-			}
-			return null;
-		}
-		return {
-			match: ctx.code.slice(position, codeOffset),
-			index: position
-		};
-		/**
-		* Get HTML entity from the given position
-		*/
-		function getHTMLEntity(position) {
-			let codeOffset = position;
-			if (ctx.code[codeOffset++] !== "&") return null;
-			let entity = "";
-			const entityDecoder = new EntityDecoder(htmlDecodeTree, (cp) => entity += String.fromCodePoint(cp));
-			entityDecoder.startEntity(DecodingMode.Attribute);
-			const length = entityDecoder.write(ctx.code, codeOffset);
-			if (length < 0) return null;
-			if (length === 0) return null;
-			return {
-				entity,
-				length
-			};
-		}
-	}
-}
-/**
-* Skip spaces
-*/
-function skipSpaces(string, position) {
-	const re = /\s*/g;
-	re.lastIndex = position;
-	const match = re.exec(string);
-	if (match) return match.index + match[0].length;
-	return position;
-}
-/**
-* Get children
-*/
-function getSortedChildren(parent, code) {
-	if (parent.type === "root" && parent.children[0]?.type === "frontmatter") {
-		const children = [...parent.children];
-		if (children.every((n) => n.position)) return children.sort((a, b) => a.position.start.offset - b.position.start.offset);
-		let start = skipSpaces(code, 0);
-		if (code.startsWith("<!", start)) {
-			const frontmatter = children.shift();
-			const before = [];
-			let first;
-			while (first = children.shift()) {
-				start = skipSpaces(code, start);
-				if (first.type === "comment" && code.startsWith("<!--", start)) {
-					start = code.indexOf("-->", start + 4) + 3;
-					before.push(first);
-				} else if (first.type === "doctype" && code.startsWith("<!", start)) {
-					start = code.indexOf(">", start + 2) + 1;
-					before.push(first);
-				} else {
-					children.unshift(first);
-					break;
-				}
-			}
-			return [
-				...before,
-				frontmatter,
-				...children
-			];
-		}
-	}
-	return parent.children;
-}
-//#endregion
 //#region src/context/restore.ts
 var RestoreNodeProcessContext = class {
+	result;
+	removeTokens = /* @__PURE__ */ new Set();
+	nodeMap;
 	constructor(result, nodeMap) {
-		this.removeTokens = /* @__PURE__ */ new Set();
 		this.result = result;
 		this.nodeMap = nodeMap;
 	}
@@ -1239,11 +581,12 @@ var RestoreNodeProcessContext = class {
 	}
 };
 var RestoreContext = class {
+	ctx;
+	offsets = [];
+	virtualFragments = [];
+	restoreNodeProcesses = [];
+	tokens = [];
 	constructor(ctx) {
-		this.offsets = [];
-		this.virtualFragments = [];
-		this.restoreNodeProcesses = [];
-		this.tokens = [];
 		this.ctx = ctx;
 	}
 	addRestoreNodeProcess(process) {
@@ -1369,9 +712,11 @@ function restoreNodes(result, nodeMap, restoreNodeProcesses) {
 //#endregion
 //#region src/context/script.ts
 var VirtualScriptContext = class {
+	originalCode;
+	restoreContext;
+	script = "";
+	consumedIndex = 0;
 	constructor(ctx) {
-		this.script = "";
-		this.consumedIndex = 0;
 		this.originalCode = ctx.code;
 		this.restoreContext = new RestoreContext(ctx);
 	}
@@ -1381,21 +726,393 @@ var VirtualScriptContext = class {
 	skipUntilOriginalOffset(offset) {
 		this.consumedIndex = Math.max(offset, this.consumedIndex);
 	}
-	appendOriginal(index) {
-		if (this.consumedIndex >= index) return;
-		this.restoreContext.addOffset({
-			original: this.consumedIndex,
-			dist: this.script.length
-		});
-		this.script += this.originalCode.slice(this.consumedIndex, index);
-		this.consumedIndex = index;
+	appendOriginal(index) {
+		if (this.consumedIndex >= index) return;
+		this.restoreContext.addOffset({
+			original: this.consumedIndex,
+			dist: this.script.length
+		});
+		this.script += this.originalCode.slice(this.consumedIndex, index);
+		this.consumedIndex = index;
+	}
+	appendVirtualScript(virtualFragment) {
+		const start = this.script.length;
+		this.script += virtualFragment;
+		this.restoreContext.addVirtualFragmentRange(start, this.script.length);
+	}
+};
+//#endregion
+//#region src/util/index.ts
+/**
+* Uses a binary search to determine the highest index at which value should be inserted into array in order to maintain its sort order.
+*/
+function sortedLastIndex(array, compare) {
+	let lower = 0;
+	let upper = array.length;
+	while (lower < upper) {
+		const mid = Math.floor(lower + (upper - lower) / 2);
+		const target = compare(array[mid]);
+		if (target < 0) lower = mid + 1;
+		else if (target > 0) upper = mid;
+		else return mid + 1;
+	}
+	return upper;
+}
+/**
+* Add element to a sorted array
+*/
+function addElementToSortedArray(array, element, compare) {
+	const index = sortedLastIndex(array, (target) => compare(target, element));
+	array.splice(index, 0, element);
+}
+/**
+* Add element to a sorted array
+*/
+function addElementsToSortedArray(array, elements, compare) {
+	if (!elements.length) return;
+	let last = elements[0];
+	let index = sortedLastIndex(array, (target) => compare(target, last));
+	for (const element of elements) {
+		if (compare(last, element) > 0) index = sortedLastIndex(array, (target) => compare(target, element));
+		let e = array[index];
+		while (e && compare(e, element) <= 0) e = array[++index];
+		array.splice(index, 0, element);
+		last = element;
+	}
+}
+//#endregion
+//#region src/parser/scope/index.ts
+const REFERENCE_TYPE_VALUE_FLAG = 1;
+const REFERENCE_TYPE_TYPE_FLAG = 2;
+/**
+* Gets the scope for the Program node
+*/
+function getProgramScope(scopeManager) {
+	const globalScope = scopeManager.globalScope;
+	return globalScope.childScopes.find((s) => s.type === "module") || globalScope;
+}
+/** Remove all scope, variable, and reference */
+function removeAllScopeAndVariableAndReference(target, info) {
+	const removeTargetScopes = /* @__PURE__ */ new Set();
+	traverseNodes(target, {
+		visitorKeys: info.visitorKeys,
+		enterNode(node) {
+			const scope = info.scopeManager.acquire(node);
+			if (scope) {
+				removeTargetScopes.add(scope);
+				return;
+			}
+			if (node.type === "Identifier" || node.type === "JSXIdentifier") {
+				let targetScope = getInnermostScopeFromNode(info.scopeManager, node);
+				while (targetScope && targetScope.block.type !== "Program" && target.range[0] <= targetScope.block.range[0] && targetScope.block.range[1] <= target.range[1]) targetScope = targetScope.upper;
+				if (removeTargetScopes.has(targetScope)) return;
+				removeIdentifierVariable(node, targetScope);
+				removeIdentifierReference(node, targetScope);
+			}
+		},
+		leaveNode() {}
+	});
+	for (const scope of removeTargetScopes) removeScope(info.scopeManager, scope);
+}
+/**
+* Add the virtual reference.
+*/
+function addVirtualReference(node, variable, scope, status) {
+	const reference = new Reference(node, scope, status.write && status.read ? eslintScope$1.Reference.RW : status.write ? eslintScope$1.Reference.WRITE : eslintScope$1.Reference.READ, void 0, void 0, void 0, status.typeRef ? REFERENCE_TYPE_TYPE_FLAG : REFERENCE_TYPE_VALUE_FLAG);
+	reference.astroVirtualReference = true;
+	addReference(variable.references, reference);
+	reference.resolved = variable;
+	if (status.forceUsed) variable.eslintUsed = true;
+	return reference;
+}
+/**
+* Add global variable
+*/
+function addGlobalVariable(reference, scopeManager) {
+	const globalScope = scopeManager.globalScope;
+	const name = reference.identifier.name;
+	let variable = globalScope.set.get(name);
+	if (!variable) {
+		variable = new Variable(name, globalScope);
+		globalScope.variables.push(variable);
+		globalScope.set.set(name, variable);
+	}
+	reference.resolved = variable;
+	variable.references.push(reference);
+	return variable;
+}
+/** Remove reference from through */
+function removeReferenceFromThrough(reference, baseScope) {
+	const variable = reference.resolved;
+	const name = reference.identifier.name;
+	let scope = baseScope;
+	while (scope) {
+		for (const ref of [...scope.through]) if (reference === ref) scope.through.splice(scope.through.indexOf(ref), 1);
+		else if (ref.identifier.name === name) {
+			ref.resolved = variable;
+			if (!variable.references.includes(ref)) addReference(variable.references, ref);
+			scope.through.splice(scope.through.indexOf(ref), 1);
+		}
+		scope = scope.upper;
+	}
+}
+/** Remove scope */
+function removeScope(scopeManager, scope) {
+	for (const childScope of scope.childScopes) removeScope(scopeManager, childScope);
+	while (scope.references[0]) removeReference(scope.references[0], scope);
+	const upper = scope.upper;
+	if (upper) {
+		const index = upper.childScopes.indexOf(scope);
+		if (index >= 0) upper.childScopes.splice(index, 1);
+	}
+	const index = scopeManager.scopes.indexOf(scope);
+	if (index >= 0) scopeManager.scopes.splice(index, 1);
+}
+/** Remove reference */
+function removeReference(reference, baseScope) {
+	if (reference.resolved) if (reference.resolved.defs.some((d) => d.name === reference.identifier)) {
+		const varIndex = baseScope.variables.indexOf(reference.resolved);
+		if (varIndex >= 0) baseScope.variables.splice(varIndex, 1);
+		const name = reference.identifier.name;
+		if (reference.resolved === baseScope.set.get(name)) baseScope.set.delete(name);
+	} else {
+		const refIndex = reference.resolved.references.indexOf(reference);
+		if (refIndex >= 0) reference.resolved.references.splice(refIndex, 1);
+	}
+	let scope = baseScope;
+	while (scope) {
+		const refIndex = scope.references.indexOf(reference);
+		if (refIndex >= 0) scope.references.splice(refIndex, 1);
+		const throughIndex = scope.through.indexOf(reference);
+		if (throughIndex >= 0) scope.through.splice(throughIndex, 1);
+		scope = scope.upper;
+	}
+}
+/** Remove variable */
+function removeIdentifierVariable(node, scope) {
+	for (let varIndex = 0; varIndex < scope.variables.length; varIndex++) {
+		const variable = scope.variables[varIndex];
+		const defIndex = variable.defs.findIndex((def) => def.name === node);
+		if (defIndex < 0) continue;
+		variable.defs.splice(defIndex, 1);
+		if (variable.defs.length === 0) {
+			referencesToThrough(variable.references, scope);
+			variable.references.forEach((r) => {
+				if (r.init) r.init = false;
+				r.resolved = null;
+			});
+			scope.variables.splice(varIndex, 1);
+			const name = node.name;
+			if (variable === scope.set.get(name)) scope.set.delete(name);
+		} else {
+			const idIndex = variable.identifiers.indexOf(node);
+			if (idIndex >= 0) variable.identifiers.splice(idIndex, 1);
+		}
+		return;
+	}
+}
+/** Remove reference */
+function removeIdentifierReference(node, scope) {
+	const reference = scope.references.find((ref) => ref.identifier === node);
+	if (reference) {
+		removeReference(reference, scope);
+		return true;
+	}
+	const location = node.range[0];
+	const pendingScopes = [];
+	for (const childScope of scope.childScopes) {
+		const range = childScope.block.range;
+		if (range[0] <= location && location < range[1]) {
+			if (removeIdentifierReference(node, childScope)) return true;
+		} else pendingScopes.push(childScope);
+	}
+	for (const childScope of pendingScopes) if (removeIdentifierReference(node, childScope)) return true;
+	return false;
+}
+/**
+* Get the innermost scope which contains a given node.
+* @returns The innermost scope.
+*/
+function getInnermostScopeFromNode(scopeManager, currentNode) {
+	return getInnermostScope(getScopeFromNode(scopeManager, currentNode), currentNode);
+}
+/**
+* Gets the scope for the current node
+*/
+function getScopeFromNode(scopeManager, currentNode) {
+	let node = currentNode;
+	for (; node; node = node.parent || null) {
+		const scope = scopeManager.acquire(node, false);
+		if (scope) {
+			if (scope.type === "function-expression-name") return scope.childScopes[0];
+			if (scope.type === "global" && node.type === "Program" && node.sourceType === "module") return scope.childScopes.find((s) => s.type === "module") || scope;
+			return scope;
+		}
+	}
+	return scopeManager.globalScope;
+}
+/**
+* Get the innermost scope which contains a given location.
+* @param initialScope The initial scope to search.
+* @param node The location to search.
+* @returns The innermost scope.
+*/
+function getInnermostScope(initialScope, node) {
+	for (const childScope of initialScope.childScopes) {
+		const range = childScope.block.range;
+		if (range[0] <= node.range[0] && node.range[1] <= range[1]) return getInnermostScope(childScope, node);
 	}
-	appendVirtualScript(virtualFragment) {
-		const start = this.script.length;
-		this.script += virtualFragment;
-		this.restoreContext.addVirtualFragmentRange(start, this.script.length);
+	return initialScope;
+}
+/** Move reference to through */
+function referencesToThrough(references, baseScope) {
+	let scope = baseScope;
+	while (scope) {
+		addAllReferences(scope.through, references);
+		scope = scope.upper;
 	}
-};
+}
+/**
+* Add all references to array
+*/
+function addAllReferences(list, elements) {
+	addElementsToSortedArray(list, elements, (a, b) => a.identifier.range[0] - b.identifier.range[0]);
+}
+/**
+* Add reference to array
+*/
+function addReference(list, reference) {
+	addElementToSortedArray(list, reference, (a, b) => a.identifier.range[0] - b.identifier.range[0]);
+}
+//#endregion
+//#region src/astro/node.ts
+/** Check whether the given node is a JSX element or fragment. */
+function isJSXElementOrFragment(node) {
+	return node.type === "JSXElement" || node.type === "JSXFragment";
+}
+/**
+* Check whether a JSX fragment is only a compiler wrapper.
+*
+* e.g `<div></div><div></div>`
+*
+* In this case, the compiler wraps the two divs in a fragment,
+* but the fragment itself has no location in the source code.
+* We can identify such fragments by checking if their opening and closing tags have zero length.
+*/
+function isSyntheticFragment(node) {
+	return node.openingFragment.start === node.openingFragment.end && (node.closingFragment == null || node.closingFragment.start === node.closingFragment.end);
+}
+/** Check whether an attribute uses Astro shorthand syntax. */
+function isShorthandAttribute(attr, code) {
+	if (attr.type !== "JSXAttribute" || attr.name.type !== "JSXIdentifier" || attr.value?.type !== "JSXExpressionContainer") return false;
+	return (isIdentifier(attr.value.expression) ? attr.value.expression.name : code.slice(attr.value.expression.start, attr.value.expression.end)) === attr.name.name && attr.value.expression.start === attr.name.start && attr.value.expression.end === attr.name.end;
+}
+/** Check whether an unknown value has the node location shape. */
+function isNode(node) {
+	return Boolean(node) && typeof node === "object" && typeof node.type === "string" && typeof node.start === "number" && typeof node.end === "number";
+}
+/** Check whether the given node is an identifier. */
+function isIdentifier(node) {
+	return isNode(node) && node.type === "Identifier";
+}
+//#endregion
+//#region src/astro/walker.ts
+/**
+* Walk the compiler AST.
+* The `enter` callback is called when entering a node, and the `leave` callback is called when leaving a node.
+* The `ctx` object passed to the callbacks has two methods: `skipChildren()` to skip walking the children of the current node, and `break()` to stop walking entirely.
+* The callbacks are called in depth-first order.
+*/
+function walk(parent, enter, leave) {
+	const childNodes = getChildNodes(parent);
+	const parents = [parent];
+	for (const child of childNodes) if (walkNode(child, enter, leave || (() => {}), parents).break) break;
+}
+/** Walk one compiler child node. */
+function walkNode(node, enter, leave, parents) {
+	const buffer = [{
+		node,
+		parents
+	}];
+	let shouldBreak = false;
+	let shouldSkipChildren = false;
+	const currentCtx = {
+		skipChildren() {
+			shouldSkipChildren = true;
+		},
+		break() {
+			shouldBreak = true;
+		}
+	};
+	while (buffer.length > 0) {
+		const current = buffer.pop();
+		enter(current.node, current.parents, currentCtx);
+		if (shouldBreak) return { break: true };
+		if (shouldSkipChildren) shouldSkipChildren = false;
+		else {
+			const childNodes = getChildNodes(current.node);
+			const parents = [current.node, ...current.parents];
+			for (let i = childNodes.length - 1; i >= 0; i--) buffer.push({
+				node: childNodes[i],
+				parents
+			});
+		}
+		leave(current.node, current.parents, currentCtx);
+		if (shouldBreak) return { break: true };
+	}
+	return {};
+}
+/**
+* Get child nodes of a compiler node.
+*/
+function getChildNodes(node) {
+	if (isAstroRoot(node)) return [...node.frontmatter ? [node.frontmatter] : [], ...node.body].sort((a, b) => a.start - b.start);
+	if (isAstroFrontmatter(node)) return [node.program];
+	if (isAstroComment(node) || isAstroDoctype(node)) return [];
+	if (isJSXFragment(node)) return [
+		node.openingFragment,
+		...node.children,
+		...node.closingFragment ? [node.closingFragment] : []
+	];
+	if (isJSXElement(node)) return [
+		node.openingElement,
+		...node.children,
+		...node.closingElement ? [node.closingElement] : []
+	];
+	const keys = getKeys(node);
+	const children = [];
+	for (const key of keys) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const element of value) if (isNode(element)) children.push(element);
+		} else if (isNode(value)) children.push(value);
+	}
+	return children.sort((a, b) => a.start - b.start);
+}
+/** Check whether the given node is a JSX element */
+function isJSXElement(node) {
+	return node.type === "JSXElement";
+}
+/** Check whether the given node is a JSX fragment */
+function isJSXFragment(node) {
+	return node.type === "JSXFragment";
+}
+/** Check whether the given node is the root node of the Astro AST. */
+function isAstroRoot(node) {
+	return node.type === "AstroRoot";
+}
+/** Check whether the given node is a walkable template node. */
+function isAstroFrontmatter(node) {
+	return node.type === "AstroFrontmatter";
+}
+/** Check whether the given node is a walkable template node. */
+function isAstroComment(node) {
+	return node.type === "AstroComment";
+}
+/** Check whether the given node is a walkable template node. */
+function isAstroDoctype(node) {
+	return node.type === "AstroDoctype";
+}
 //#endregion
 //#region src/parser/process-template.ts
 /**
@@ -1405,6 +1122,7 @@ function processTemplate(ctx, resultTemplate) {
 	let uniqueIdSeq = 0;
 	const usedUniqueIds = /* @__PURE__ */ new Set();
 	const script = new VirtualScriptContext(ctx);
+	const code = ctx.code;
 	let fragmentOpened = false;
 	/** Open astro root fragment */
 	function openRootFragment(startOffset) {
@@ -1422,20 +1140,21 @@ function processTemplate(ctx, resultTemplate) {
 			return false;
 		});
 	}
-	walkElements(resultTemplate.ast, ctx.code, (node, [parent]) => {
-		if (node.type === "frontmatter") {
-			const start = node.position.start.offset;
+	walkElements(resultTemplate.ast, (node) => {
+		if (node.type === "AstroFrontmatter") {
 			if (fragmentOpened) {
 				script.appendVirtualScript("</>;");
 				fragmentOpened = false;
 			}
+			let start = node.start;
+			while (code[start] !== "-") start++;
 			script.appendOriginal(start);
 			script.skipOriginalOffset(3);
-			const end = getEndOffset(node, ctx);
+			const end = node.end;
 			const scriptStart = start + 3;
 			let scriptEnd = end - 3;
 			let endChar;
-			while (scriptStart < scriptEnd - 1 && (endChar = ctx.code[scriptEnd - 1]) && !endChar.trim()) scriptEnd--;
+			while (scriptStart < scriptEnd - 1 && (endChar = code[scriptEnd - 1]) && !endChar.trim()) scriptEnd--;
 			script.appendOriginal(scriptEnd);
 			script.appendVirtualScript("\n;");
 			script.skipOriginalOffset(end - scriptEnd);
@@ -1451,132 +1170,136 @@ function processTemplate(ctx, resultTemplate) {
 				}
 				return true;
 			});
-			script.restoreContext.addToken(AST_TOKEN_TYPES.Punctuator, [node.position.start.offset, node.position.start.offset + 3]);
+			script.restoreContext.addToken(AST_TOKEN_TYPES.Punctuator, [start, start + 3]);
 			script.restoreContext.addToken(AST_TOKEN_TYPES.Punctuator, [end - 3, end]);
-		} else if (isTag(node)) {
-			if (parent.type === "expression") {
-				const siblings = parent.children.filter((n) => n.type !== "text" || n.value.trim());
-				const index = siblings.indexOf(node);
-				const before = siblings[index - 1];
-				if (!before || !isTag(before)) {
-					const after = siblings[index + 1];
-					if (after && (isTag(after) || after.type === "comment")) {
-						const start = node.position.start.offset;
+		} else if (isJSXElementOrFragment(node)) {
+			const start = node.start;
+			script.appendOriginal(start);
+			if (!fragmentOpened) openRootFragment(start);
+			if (node.type === "JSXFragment") {
+				if (isSyntheticFragment(node)) {
+					const start = node.start;
+					script.appendOriginal(start);
+					script.appendVirtualScript("<>");
+					script.restoreContext.addRestoreNodeProcess((scriptNode) => {
+						if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES.JSXFragment) {
+							delete scriptNode.openingFragment;
+							delete scriptNode.closingFragment;
+							const fragmentNode = scriptNode;
+							fragmentNode.type = "AstroFragment";
+							const last = fragmentNode.children[fragmentNode.children.length - 1];
+							if (last && fragmentNode.range[1] < last.range[1]) {
+								fragmentNode.range[1] = last.range[1];
+								fragmentNode.loc.end = ctx.getLocFromIndex(fragmentNode.range[1]);
+							}
+							return true;
+						}
+						return false;
+					});
+				}
+			} else {
+				const tagType = getTagType(node);
+				for (const attr of node.openingElement.attributes) {
+					const analyzed = analyzeAttribute(attr);
+					if (analyzed.kind === "literal-value" || analyzed.kind === "empty" || analyzed.kind === "expression" || analyzed.kind === "template-literal") {
+						const attrName = getJsxName(analyzed.node.name);
+						if (tagType === "component" ? /[.:@]/u.test(attrName) : /[.@]/u.test(attrName) || attrName.startsWith(":")) processAttributePunctuators(analyzed.node);
+					}
+					if (analyzed.kind === "literal-value") {
+						const raw = code.slice(analyzed.node.value.start, analyzed.node.value.end);
+						if (raw && !raw.startsWith("\"") && !raw.startsWith("'")) {
+							const attrStart = analyzed.node.start;
+							const valueStart = analyzed.node.value.start;
+							const attrEnd = analyzed.node.end;
+							script.appendOriginal(valueStart);
+							script.appendVirtualScript("\"");
+							script.appendOriginal(attrEnd);
+							script.appendVirtualScript("\"");
+							script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
+								if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
+									const attrNode = scriptNode;
+									if (attrNode.value?.type === "Literal" && typeof attrNode.value.value === "string") {
+										const raw = code.slice(valueStart, attrEnd);
+										attrNode.value.raw = raw;
+										context.findToken(valueStart).value = raw;
+										return true;
+									}
+								}
+								return false;
+							});
+						}
+					} else if (analyzed.kind === "shorthand") {
+						const attrName = getJsxName(analyzed.node.name);
+						const start = getShorthandAttributeOpeningBraceOffset(analyzed.node);
 						script.appendOriginal(start);
-						script.appendVirtualScript("<>");
+						const jsxName = /[\s"'[\]{}]/u.test(attrName) ? generateUniqueId(attrName) : attrName;
+						script.appendVirtualScript(`${jsxName}=`);
 						script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-							if (scriptNode.range[0] === start && scriptNode.type === AST_NODE_TYPES.JSXFragment) {
-								delete scriptNode.openingFragment;
-								delete scriptNode.closingFragment;
-								const fragmentNode = scriptNode;
-								fragmentNode.type = "AstroFragment";
-								const last = fragmentNode.children[fragmentNode.children.length - 1];
-								if (fragmentNode.range[1] < last.range[1]) {
-									fragmentNode.range[1] = last.range[1];
-									fragmentNode.loc.end = ctx.getLocFromIndex(fragmentNode.range[1]);
-								}
+							if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start) {
+								const attrNode = scriptNode;
+								attrNode.type = "AstroShorthandAttribute";
+								const locs = ctx.getLocations(...attrNode.value.expression.range);
+								if (jsxName !== attrName) attrNode.name.name = attrName;
+								attrNode.name.range = locs.range;
+								attrNode.name.loc = locs.loc;
 								return true;
 							}
 							return false;
 						});
-					}
-				}
-			}
-			const start = node.position.start.offset;
-			script.appendOriginal(start);
-			if (!fragmentOpened) openRootFragment(start);
-			for (const attr of node.attributes) {
-				if (attr.kind === "quoted" || attr.kind === "empty" || attr.kind === "expression" || attr.kind === "template-literal") {
-					if (node.type === "component" || node.type === "fragment" ? /[.:@]/u.test(attr.name) : /[.@]/u.test(attr.name) || attr.name.startsWith(":")) processAttributePunctuators(attr);
-				}
-				if (attr.kind === "quoted") {
-					if (attr.raw && !attr.raw.startsWith("\"") && !attr.raw.startsWith("'")) {
-						const attrStart = attr.position.start.offset;
-						const start = calcAttributeValueStartOffset(attr, ctx);
-						const end = calcAttributeEndOffset(attr, ctx);
-						script.appendOriginal(start);
-						script.appendVirtualScript("\"");
-						script.appendOriginal(end);
-						script.appendVirtualScript("\"");
-						script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
+					} else if (analyzed.kind === "template-literal") {
+						const attrStart = analyzed.node.start;
+						const valueStart = analyzed.node.value.start;
+						const attrEnd = analyzed.node.end;
+						script.appendOriginal(valueStart);
+						script.appendVirtualScript("{");
+						script.appendOriginal(attrEnd);
+						script.appendVirtualScript("}");
+						script.restoreContext.addRestoreNodeProcess((scriptNode) => {
 							if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
 								const attrNode = scriptNode;
-								if (attrNode.value?.type === "Literal" && typeof attrNode.value.value === "string") {
-									const raw = ctx.code.slice(start, end);
-									attrNode.value.raw = raw;
-									context.findToken(start).value = raw;
-									return true;
-								}
+								attrNode.type = "AstroTemplateLiteralAttribute";
+								return true;
 							}
 							return false;
 						});
 					}
-				} else if (attr.kind === "shorthand") {
-					const start = attr.position.start.offset;
-					script.appendOriginal(start);
-					const jsxName = /[\s"'[\]{}]/u.test(attr.name) ? generateUniqueId(attr.name) : attr.name;
-					script.appendVirtualScript(`${jsxName}=`);
-					script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-						if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === start) {
-							const attrNode = scriptNode;
-							attrNode.type = "AstroShorthandAttribute";
-							const locs = ctx.getLocations(...attrNode.value.expression.range);
-							if (jsxName !== attr.name) attrNode.name.name = attr.name;
-							attrNode.name.range = locs.range;
-							attrNode.name.loc = locs.loc;
-							return true;
-						}
-						return false;
-					});
-				} else if (attr.kind === "template-literal") {
-					const attrStart = attr.position.start.offset;
-					const start = calcAttributeValueStartOffset(attr, ctx);
-					const end = calcAttributeEndOffset(attr, ctx);
-					script.appendOriginal(start);
-					script.appendVirtualScript("{");
-					script.appendOriginal(end);
-					script.appendVirtualScript("}");
-					script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-						if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === attrStart) {
-							const attrNode = scriptNode;
-							attrNode.type = "AstroTemplateLiteralAttribute";
-							return true;
-						}
-						return false;
-					});
 				}
-			}
-			const closing = getSelfClosingTag(node, ctx);
-			if (closing && closing.end === ">") {
-				script.appendOriginal(closing.offset - 1);
-				script.appendVirtualScript("/");
-			}
-			if (node.name === "script" || node.name === "style" || node.attributes.some((attr) => attr.name === "is:raw")) {
-				const text = node.children[0];
-				if (text && text.type === "text") {
-					const styleNodeStart = node.position.start.offset;
-					const start = text.position.start.offset;
-					script.appendOriginal(start);
-					script.skipOriginalOffset(text.value.length);
-					script.restoreContext.addRestoreNodeProcess((scriptNode) => {
-						if (scriptNode.type === AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
-							scriptNode.children = [{
-								type: "AstroRawText",
-								value: text.value,
-								raw: text.value,
-								parent: scriptNode,
-								...ctx.getLocations(start, start + text.value.length)
-							}];
-							return true;
-						}
-						return false;
-					});
-					script.restoreContext.addToken(AST_TOKEN_TYPES.JSXText, [start, start + text.value.length]);
+				const closing = getSelfClosingTag(node);
+				if (closing && closing.end === ">") {
+					script.appendOriginal(closing.offset - 1);
+					script.appendVirtualScript("/");
+				}
+				const tagName = getJsxName(node.openingElement.name);
+				if (tagName === "script" || tagName === "style" || node.openingElement.attributes.some((attr) => {
+					const analyzed = analyzeAttribute(attr);
+					if (analyzed.kind === "spread") return false;
+					return getJsxName(analyzed.node.name) === "is:raw";
+				})) {
+					const text = getRawTextContent(node);
+					if (text && text.value) {
+						const styleNodeStart = node.start;
+						script.appendOriginal(text.start);
+						script.skipOriginalOffset(text.value.length);
+						script.restoreContext.addRestoreNodeProcess((scriptNode) => {
+							if (scriptNode.type === AST_NODE_TYPES.JSXElement && scriptNode.range[0] === styleNodeStart) {
+								scriptNode.children = [{
+									type: "AstroRawText",
+									value: text.value,
+									raw: text.value,
+									parent: scriptNode,
+									...ctx.getLocations(text.start, text.end)
+								}];
+								return true;
+							}
+							return false;
+						});
+						script.restoreContext.addToken(AST_TOKEN_TYPES.JSXText, [text.start, text.end]);
+					}
 				}
 			}
-		} else if (node.type === "comment") {
-			const start = node.position.start.offset;
-			const end = getEndOffset(node, ctx);
+		} else if (node.type === "AstroComment") {
+			const start = node.start;
+			const end = node.end;
 			const length = end - start;
 			script.appendOriginal(start);
 			if (!fragmentOpened) openRootFragment(start);
@@ -1600,9 +1323,9 @@ function processTemplate(ctx, resultTemplate) {
 				return false;
 			});
 			script.restoreContext.addToken("HTMLComment", [start, start + length]);
-		} else if (node.type === "doctype") {
-			const start = node.position.start.offset;
-			const end = getEndOffset(node, ctx);
+		} else if (node.type === "AstroDoctype") {
+			const start = node.start;
+			const end = node.end;
 			const length = end - start;
 			script.appendOriginal(start);
 			if (!fragmentOpened) openRootFragment(start);
@@ -1626,63 +1349,139 @@ function processTemplate(ctx, resultTemplate) {
 			});
 			script.restoreContext.addToken("HTMLDocType", [start, end]);
 		} else {
-			const start = node.position.start.offset;
+			const start = node.start;
 			script.appendOriginal(start);
 			if (!fragmentOpened) openRootFragment(start);
 		}
-	}, (node, [parent]) => {
-		if (isTag(node)) {
-			if (!getSelfClosingTag(node, ctx)) {
-				if (!getEndTag(node, ctx)) {
-					const offset = calcContentEndOffset(node, ctx);
-					script.appendOriginal(offset);
-					script.appendVirtualScript(`</${node.name}>`);
-					script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
-						const parent = context.getParent(scriptNode);
-						if (scriptNode.range[0] === offset && scriptNode.type === AST_NODE_TYPES.JSXClosingElement && parent.type === AST_NODE_TYPES.JSXElement) {
-							removeAllScopeAndVariableAndReference(scriptNode, {
-								visitorKeys: context.result.visitorKeys,
-								scopeManager: context.result.scopeManager
-							});
-							parent.closingElement = null;
-							return true;
-						}
-						return false;
-					});
-				}
+	}, (node) => {
+		if (node.type === "JSXElement") {
+			if (!getSelfClosingTag(node) && node.closingElement == null) {
+				const offset = calcContentEndOffset(node);
+				script.appendOriginal(offset);
+				script.appendVirtualScript(`</${getJsxName(node.openingElement.name)}>`);
+				script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
+					const parent = context.getParent(scriptNode);
+					if (scriptNode.range[0] === offset && scriptNode.type === AST_NODE_TYPES.JSXClosingElement && parent.type === AST_NODE_TYPES.JSXElement) {
+						removeAllScopeAndVariableAndReference(scriptNode, {
+							visitorKeys: context.result.visitorKeys,
+							scopeManager: context.result.scopeManager
+						});
+						parent.closingElement = null;
+						return true;
+					}
+					return false;
+				});
 			}
 		}
-		if ((isTag(node) || node.type === "comment") && parent.type === "expression") {
-			const siblings = parent.children.filter((n) => n.type !== "text" || n.value.trim());
-			const index = siblings.indexOf(node);
-			const after = siblings[index + 1];
-			if (!after || !isTag(after) && after.type !== "comment") {
-				const before = siblings[index - 1];
-				if (before && (isTag(before) || before.type === "comment")) {
-					const end = getEndOffset(node, ctx);
-					script.appendOriginal(end);
-					script.appendVirtualScript("</>");
-				}
-			}
+		if (node.type === "JSXFragment" && isSyntheticFragment(node)) {
+			script.appendOriginal(node.end);
+			script.appendVirtualScript("</>");
 		}
 	});
 	if (fragmentOpened) {
-		const last = resultTemplate.ast.children[resultTemplate.ast.children.length - 1];
-		const end = getEndOffset(last, ctx);
-		script.appendOriginal(end);
+		const last = findLastJSXNode(resultTemplate.ast);
+		if (last) script.appendOriginal(last.end);
 		script.appendVirtualScript("</>;");
 	}
-	script.appendOriginal(ctx.code.length);
+	script.appendOriginal(code.length);
 	return script;
 	/**
+	* Walk template nodes in source order from the compiler AST.
+	*
+	* The traversal starts with `AstroRoot`. Root-only source ranges such as
+	* frontmatter fences are handled in the root branch so they do not become
+	* node-shaped intermediate children.
+	*/
+	function walkElements(parent, enter, leave) {
+		const nodes = [...parent.body];
+		const frontmatter = parent.frontmatter;
+		if (frontmatter && !isEmptyFrontmatter(frontmatter)) {
+			let insertIndex = nodes.findIndex((child) => frontmatter.start <= child.start);
+			if (insertIndex < 0) insertIndex = nodes.length;
+			while (insertIndex > 0 && isWhitespaceJSXText(nodes[insertIndex - 1])) {
+				nodes.splice(insertIndex - 1, 1);
+				insertIndex--;
+			}
+			while (insertIndex < nodes.length && isWhitespaceJSXText(nodes[insertIndex])) nodes.splice(insertIndex, 1);
+			nodes.splice(insertIndex, 0, frontmatter);
+		}
+		while (nodes.length > 0 && isWhitespaceJSXText(nodes[0])) nodes.shift();
+		while (nodes.length > 0 && isWhitespaceJSXText(nodes[nodes.length - 1])) nodes.pop();
+		for (const child of nodes) walkChild(child, enter, leave);
+	}
+	/** Get raw text content for script, style, and raw nodes. */
+	function getRawTextContent(node) {
+		if (node.closingElement == null) return null;
+		const start = node.openingElement.end;
+		const end = node.closingElement.start;
+		if (start >= end) return null;
+		return {
+			start,
+			end,
+			value: code.slice(start, end)
+		};
+	}
+	/** Get self-closing tag metadata. */
+	function getSelfClosingTag(node) {
+		if (!node.openingElement?.selfClosing || node.closingElement) return null;
+		const offset = node.openingElement.end;
+		return {
+			offset,
+			end: code.startsWith("/>", offset - 2) ? "/>" : ">"
+		};
+	}
+	/** Get the Astro attribute kind represented by a compiler node. */
+	function analyzeAttribute(attr) {
+		if (attr.type === "JSXSpreadAttribute") return {
+			kind: "spread",
+			node: attr
+		};
+		if (!attr.value) return {
+			kind: "empty",
+			node: attr
+		};
+		if (isShorthandAttribute(attr, code)) return {
+			kind: "shorthand",
+			node: attr
+		};
+		if (attr.value.type === "Literal") return {
+			kind: "literal-value",
+			node: attr
+		};
+		if (attr.value.type === "JSXExpressionContainer" && code[attr.value.start] === "`") return {
+			kind: "template-literal",
+			node: attr
+		};
+		return {
+			kind: "expression",
+			node: attr
+		};
+	}
+	/**
+	* Get the source offset of the opening `{` for an Astro shorthand attribute.
+	*
+	* The compiler represents `<img {src}>` as a JSXAttribute that starts at
+	* `src`, while the end offset still includes `}`. The virtual JSX needs to
+	* insert `src=` before the original `{src}`, so shorthand processing must use
+	* the brace offset instead of `attr.start`.
+	*/
+	function getShorthandAttributeOpeningBraceOffset(attr) {
+		return code[attr.start - 1] === "{" ? attr.start - 1 : attr.start;
+	}
+	/** Check whether a node is whitespace-only text. */
+	function isWhitespaceJSXText(node) {
+		return node.type === "JSXText" && code.slice(node.start, node.end).trim() === "";
+	}
+	/**
 	* Process for attribute punctuators
 	*/
 	function processAttributePunctuators(attr) {
-		const start = attr.position.start.offset;
+		const name = getJsxName(attr.name);
+		const start = attr.name.start;
 		let targetIndex = start;
 		let colonOffset;
-		for (let index = 0; index < attr.name.length; index++) {
-			const char = attr.name[index];
+		for (let index = 0; index < name.length; index++) {
+			const char = name[index];
 			if (char !== ":" && char !== "." && char !== "@") continue;
 			if (index === 0) targetIndex++;
 			const punctuatorIndex = start + index;
@@ -1695,8 +1494,8 @@ function processTemplate(ctx, resultTemplate) {
 			const punctuatorIndex = start + colonOffset;
 			script.restoreContext.addToken(AST_TOKEN_TYPES.JSXIdentifier, [start, punctuatorIndex]);
 			script.restoreContext.addToken(AST_TOKEN_TYPES.Punctuator, [punctuatorIndex, punctuatorIndex + 1]);
-			script.restoreContext.addToken(AST_TOKEN_TYPES.JSXIdentifier, [punctuatorIndex + 1, start + attr.name.length]);
-		} else script.restoreContext.addToken(AST_TOKEN_TYPES.JSXIdentifier, [start, start + attr.name.length]);
+			script.restoreContext.addToken(AST_TOKEN_TYPES.JSXIdentifier, [punctuatorIndex + 1, start + name.length]);
+		} else script.restoreContext.addToken(AST_TOKEN_TYPES.JSXIdentifier, [start, start + name.length]);
 		script.restoreContext.addRestoreNodeProcess((scriptNode, context) => {
 			if (scriptNode.type === AST_NODE_TYPES.JSXAttribute && scriptNode.range[0] === targetIndex) {
 				const baseNameNode = scriptNode.name;
@@ -1705,25 +1504,27 @@ function processTemplate(ctx, resultTemplate) {
 					nameNode.type = AST_NODE_TYPES.JSXNamespacedName;
 					nameNode.namespace = {
 						type: AST_NODE_TYPES.JSXIdentifier,
-						name: attr.name.slice(0, colonOffset),
-						...ctx.getLocations(baseNameNode.range[0], baseNameNode.range[0] + colonOffset)
+						name: name.slice(0, colonOffset),
+						...ctx.getLocations(baseNameNode.range[0], baseNameNode.range[0] + colonOffset),
+						parent: void 0
 					};
 					nameNode.name = {
 						type: AST_NODE_TYPES.JSXIdentifier,
-						name: attr.name.slice(colonOffset + 1),
-						...ctx.getLocations(baseNameNode.range[0] + colonOffset + 1, baseNameNode.range[1])
+						name: name.slice(colonOffset + 1),
+						...ctx.getLocations(baseNameNode.range[0] + colonOffset + 1, baseNameNode.range[1]),
+						parent: void 0
 					};
 					scriptNode.name = nameNode;
 					nameNode.namespace.parent = nameNode;
 					nameNode.name.parent = nameNode;
 				} else if (baseNameNode.type === AST_NODE_TYPES.JSXIdentifier) {
 					const nameNode = baseNameNode;
-					nameNode.name = attr.name;
+					nameNode.name = name;
 					scriptNode.name = nameNode;
 				} else {
 					const nameNode = baseNameNode;
-					nameNode.namespace.name = attr.name.slice(baseNameNode.namespace.range[0] - start, baseNameNode.namespace.range[1] - start);
-					nameNode.name.name = attr.name.slice(baseNameNode.name.range[0] - start, baseNameNode.name.range[1] - start);
+					nameNode.namespace.name = name.slice(baseNameNode.namespace.range[0] - start, baseNameNode.namespace.range[1] - start);
+					nameNode.name.name = name.slice(baseNameNode.name.range[0] - start, baseNameNode.name.range[1] - start);
 					scriptNode.name = nameNode;
 					nameNode.namespace.parent = nameNode;
 					nameNode.name.parent = nameNode;
@@ -1739,17 +1540,90 @@ function processTemplate(ctx, resultTemplate) {
 	*/
 	function generateUniqueId(base) {
 		let candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
-		while (usedUniqueIds.has(candidate) || ctx.code.includes(candidate)) candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
+		while (usedUniqueIds.has(candidate) || code.includes(candidate)) candidate = `$_${base.replace(/\W/g, "_")}${uniqueIdSeq++}`;
 		usedUniqueIds.add(candidate);
 		return candidate;
 	}
+	/**
+	* Find the last JSXNode.
+	* Basically, it returns the last element of AstroRootNode.body.
+	* However, if the last element is a JSXTextNode, and its text is whitespace,
+	* and all preceding elements are AstroCommentNode, it returns the last AstroCommentNode.
+	*/
+	function findLastJSXNode(ast) {
+		const body = ast.body;
+		if (body.length === 0) return null;
+		const lastNode = body[body.length - 1];
+		if (isWhitespaceJSXText(lastNode) && body.length >= 2 && body.slice(0, -1).every((node) => node.type === "AstroComment")) return body[body.length - 2];
+		return lastNode;
+	}
+}
+/** Walk one compiler child node. */
+function walkChild(node, enter, leave) {
+	enter(node);
+	if (isJSXElementOrFragment(node)) for (const child of node.children) {
+		if (child.type === "AstroScript") continue;
+		walkChild(child, enter, leave);
+	}
+	else if (node.type === "JSXExpressionContainer") walkExpression(node.expression, enter, leave);
+	leave(node);
+}
+/** Walk one compiler expression node. */
+function walkExpression(node, enter, leave) {
+	const walked = /* @__PURE__ */ new Set();
+	walk(node, (child, _parents, ctx) => {
+		if (walked.has(child)) return;
+		walked.add(child);
+		if (isWalkableNode(child)) {
+			walkChild(child, enter, leave);
+			ctx.skipChildren();
+		}
+	});
+}
+/**
+* Check whether the given node is a walkable template node that should be passed through the enter/leave hooks.
+*/
+function isWalkableNode(node) {
+	return isJSXElementOrFragment(node) || node.type === "AstroComment" || node.type === "AstroDoctype" || node.type === "JSXExpressionContainer" || node.type === "JSXText";
+}
+/**
+* Check whether the frontmatter is empty (i.e. contains no characters).
+* In this case, the frontmatter node is still generated by the compiler,
+* but it has no source range. We can identify such empty frontmatter by checking if the start and end offsets are the same.
+*/
+function isEmptyFrontmatter(node) {
+	return node.start === node.end;
+}
+/** Convert a compiler JSX name node to source text. */
+function getJsxName(nameNode) {
+	if (nameNode.type === "JSXIdentifier") return nameNode.name;
+	if (nameNode.type === "JSXMemberExpression") return `${getJsxName(nameNode.object)}.${getJsxName(nameNode.property)}`;
+	if (nameNode.type === "JSXNamespacedName") return `${getJsxName(nameNode.namespace)}:${getJsxName(nameNode.name)}`;
+	return "";
+}
+/** Get the Astro tag category for a traversal node. */
+function getTagType(node) {
+	const name = getJsxName(node.openingElement.name);
+	if (/^[A-Z]/u.test(name) || name.includes(".")) return "component";
+	if (name.includes("-")) return "custom-element";
+	return "element";
+}
+/** Calculate where an element without a closing tag should end. */
+function calcContentEndOffset(node) {
+	const children = node.children;
+	const lastChild = children[children.length - 1];
+	if (lastChild) return lastChild.end;
+	return node.openingElement.end;
 }
 //#endregion
 //#region src/context/index.ts
 var Context = class {
+	code;
+	filePath;
+	locs;
+	locsMap = /* @__PURE__ */ new Map();
+	state = {};
 	constructor(code, filePath) {
-		this.locsMap = /* @__PURE__ */ new Map();
-		this.state = {};
 		this.locs = new LinesAndColumns(code);
 		this.code = code;
 		this.filePath = filePath;
@@ -1804,31 +1678,19 @@ var Context = class {
 	}
 };
 var LinesAndColumns = class {
+	lineStartIndices;
+	code;
 	constructor(origCode) {
 		const len = origCode.length;
 		const lineStartIndices = [0];
-		const crs = [];
-		let normalizedCode = "";
 		for (let index = 0; index < len;) {
 			const c = origCode[index++];
-			if (c === "\r") {
-				const next = origCode[index++] || "";
-				if (next === "\n") {
-					normalizedCode += next;
-					crs.push(index - 2);
-					lineStartIndices.push(index);
-				} else {
-					normalizedCode += `\n${next}`;
-					lineStartIndices.push(index - 1);
-				}
-			} else {
-				normalizedCode += c;
-				if (c === "\n") lineStartIndices.push(index);
-			}
+			if (c === "\r") if ((origCode[index++] || "") === "\n") lineStartIndices.push(index);
+			else lineStartIndices.push(index - 1);
+			else if (c === "\n") lineStartIndices.push(index);
 		}
 		this.lineStartIndices = lineStartIndices;
 		this.code = origCode;
-		this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
 	}
 	getLocFromIndex(index) {
 		const lineNumber = sortedLastIndex(this.lineStartIndices, (target) => target - index);
@@ -1843,264 +1705,145 @@ var LinesAndColumns = class {
 		else if (this.lineStartIndices.length === lineIndex) return this.code.length + loc.column;
 		return this.code.length + loc.column;
 	}
-	getNormalizedLineFeed() {
-		return this.normalizedLineFeed;
-	}
-};
-var NormalizedLineFeed = class {
-	get needRemap() {
-		return this.offsets.length > 0;
-	}
-	constructor(code, offsets) {
-		this.code = code;
-		this.offsets = offsets;
-		if (offsets.length) {
-			const cache = {};
-			this.remapIndex = (index) => {
-				let result = cache[index];
-				if (result != null) return result;
-				result = index;
-				for (const offset of offsets) if (offset < result) result++;
-				else break;
-				return cache[index] = result;
-			};
-		} else this.remapIndex = (i) => i;
-	}
 };
 //#endregion
-//#region src/parser/astro-parser/parse.ts
-/**
-* Parse code by `@astrojs/compiler`
-*/
-function parse(code, ctx) {
-	const result = service.parse(code, { position: true });
-	for (const { code, text, location, severity } of result.diagnostics || []) if (severity === 1) {
-		ctx.originalAST = result.ast;
-		throw new ParseError(`${text} [${code}]`, location, ctx);
-	}
-	if (!result.ast.children) result.ast.children = [];
-	const htmlElement = result.ast.children.find((n) => n.type === "element" && n.name === "html");
-	if (!result._adjusted) {
-		if (htmlElement) adjustHTML(result.ast, htmlElement, ctx);
-		fixLocations(result.ast, ctx);
-		result._adjusted = true;
-	}
-	return result;
-}
+//#region src/errors.ts
 /**
-* Adjust <html> element node
+* Astro parse errors.
 */
-function adjustHTML(ast, htmlElement, ctx) {
-	const htmlEnd = ctx.code.indexOf("</html");
-	if (htmlEnd < 0) return;
-	const isOffsetAfter = buildComparableOffsetComparator(ctx.code);
-	const hasTokenAfter = Boolean(ctx.code.slice(htmlEnd + 7).trim());
-	const children = [...htmlElement.children];
-	for (const child of children) {
-		const offset = child.position?.start.offset;
-		if (hasTokenAfter && offset != null) {
-			if (isOffsetAfter(offset, htmlEnd)) {
-				htmlElement.children.splice(htmlElement.children.indexOf(child), 1);
-				ast.children.push(child);
-			}
-		}
-		if (child.type === "element" && child.name === "body") adjustHTMLBody(ast, htmlElement, htmlEnd, hasTokenAfter, child, ctx, isOffsetAfter);
-	}
-	/**
-	* Build a comparator used only for matching compiler offsets against
-	* positions derived from `ctx.code`.
-	*
-	* The raw offset check is important for laziness: if the compiler offset is
-	* already before the threshold, remapping cannot make it jump forward past
-	* that threshold, so we can reject it without any byte/code-unit work.
-	*/
-	function buildComparableOffsetComparator(code) {
-		let remapOffset;
-		const comparableOffsetCache = /* @__PURE__ */ new Map();
-		return (offset, threshold) => {
-			if (threshold > offset) return false;
-			let comparableOffset = comparableOffsetCache.get(offset);
-			if (comparableOffset == null) {
-				remapOffset ||= buildComparableOffsetRemapper(code);
-				comparableOffset = remapOffset(offset);
-				comparableOffsetCache.set(offset, comparableOffset);
-			}
-			return threshold <= comparableOffset;
-		};
-	}
+var ParseError = class extends SyntaxError {
+	index;
+	lineNumber;
+	column;
+	originalAST;
 	/**
-	* Build remapper used only for comparing compiler offsets with `ctx.code`.
+	* Initialize this ParseError instance.
 	*/
-	function buildComparableOffsetRemapper(code) {
-		let byteOffsets, codeUnitOffsets;
-		for (let index = 0, byteOffset = 0; index < code.length;) {
-			const codePoint = code.codePointAt(index);
-			const nextIndex = index + (codePoint > 65535 ? 2 : 1);
-			const nextByteOffset = byteOffset + getUTF8ByteLength(codePoint);
-			if (byteOffsets) {
-				byteOffsets.push(nextByteOffset);
-				codeUnitOffsets.push(nextIndex);
-			} else if (codePoint > 127) {
-				byteOffsets = [0];
-				codeUnitOffsets = [0];
-				for (let asciiOffset = 1; asciiOffset <= index; asciiOffset++) {
-					byteOffsets.push(asciiOffset);
-					codeUnitOffsets.push(asciiOffset);
-				}
-				byteOffsets.push(nextByteOffset);
-				codeUnitOffsets.push(nextIndex);
-			}
-			index = nextIndex;
-			byteOffset = nextByteOffset;
+	constructor(message, offset, ctx) {
+		super(message);
+		if (typeof offset === "number") {
+			this.index = offset;
+			const loc = ctx.getLocFromIndex(offset);
+			this.lineNumber = loc.line;
+			this.column = loc.column;
+		} else {
+			this.index = ctx.getIndexFromLoc(offset);
+			this.lineNumber = offset.line;
+			this.column = offset.column;
 		}
-		if (!byteOffsets || !codeUnitOffsets) return (offset) => offset;
-		return (offset) => {
-			const index = sortedLastIndex(byteOffsets, (target) => target - offset) - 1;
-			return codeUnitOffsets[Math.max(index, 0)];
-		};
-	}
-	/**
-	* Get UTF-8 byte length for code point.
-	*/
-	function getUTF8ByteLength(codePoint) {
-		if (codePoint <= 127) return 1;
-		if (codePoint <= 2047) return 2;
-		if (codePoint <= 65535) return 3;
-		return 4;
+		this.originalAST = ctx.originalAST;
 	}
-}
+};
+//#endregion
+//#region src/parser/astro-parser/parse.ts
 /**
-* Adjust <body> element node
-*/
-function adjustHTMLBody(ast, htmlElement, htmlEnd, hasTokenAfterHtmlEnd, bodyElement, ctx, isOffsetAfter) {
-	const bodyEnd = ctx.code.indexOf("</body");
-	if (bodyEnd == null) return;
-	const hasTokenAfter = Boolean(ctx.code.slice(bodyEnd + 7, htmlEnd).trim());
-	if (!hasTokenAfter && !hasTokenAfterHtmlEnd) return;
-	const children = [...bodyElement.children];
-	for (const child of children) {
-		const offset = child.position?.start.offset;
-		if (offset != null && isOffsetAfter(offset, bodyEnd)) {
-			if (hasTokenAfterHtmlEnd && isOffsetAfter(offset, htmlEnd)) {
-				bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
-				ast.children.push(child);
-			} else if (hasTokenAfter) {
-				bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
-				htmlElement.children.push(child);
-			}
-		}
+* Parse code by `@astrojs/compiler-rs`.
+*
+* The compiler returns locations in its own offset format. Normalize them here
+* before any later parser phase reads the AST, so the rest of the parser can
+* treat every `start`/`end` and diagnostic label as ESLint-compatible source
+* indexes.
+*/
+function parse$1(code, ctx) {
+	const result = parse(code);
+	normalizeLocations(result, code, ctx);
+	for (const diagnostic of result.diagnostics || []) {
+		if (diagnostic.severity !== "error") continue;
+		ctx.originalAST = result.ast;
+		const location = diagnostic.labels?.[0]?.start ?? 0;
+		throw new ParseError(diagnostic.text, location, ctx);
 	}
+	return result;
 }
 /**
-* Fix locations
-*/
-function fixLocations(node, ctx) {
-	let start = 0;
-	walk(node, ctx.code, (node, [parent]) => {
-		if (node.type === "frontmatter") {
-			start = node.position.start.offset = tokenIndex(ctx, "---", start);
-			if (!node.position.end) node.position.end = {};
-			start = node.position.end.offset = tokenIndex(ctx, "---", start + 3 + node.value.length) + 3;
-		} else if (node.type === "fragment" || node.type === "element" || node.type === "component" || node.type === "custom-element") {
-			if (!node.position) node.position = {
-				start: {},
-				end: {}
-			};
-			start = node.position.start.offset = tokenIndex(ctx, "<", start);
-			start += 1;
-			start += node.name.length;
-			if (!node.attributes.length) start = calcStartTagEndOffset(node, ctx);
-		} else if (node.type === "attribute") {
-			fixLocationForAttr(node, ctx, start);
-			start = calcAttributeEndOffset(node, ctx);
-			if (node.position.end) node.position.end.offset = start;
-		} else if (node.type === "comment") {
-			node.position.start.offset = tokenIndex(ctx, "<!--", start);
-			start = calcCommentEndOffset(node, ctx);
-			if (node.position.end) node.position.end.offset = start;
-		} else if (node.type === "text") {
-			if (parent.type === "element" && (parent.name === "script" || parent.name === "style")) {
-				node.position.start.offset = start;
-				start = ctx.code.indexOf(`</${parent.name}`, start);
-				if (start < 0) start = ctx.code.length;
-			} else {
-				const index = tokenIndexSafe(ctx.code, node.value, start);
-				if (index != null) {
-					start = node.position.start.offset = index;
-					start += node.value.length;
-				} else {
-					node.position.start.offset = start;
-					const value = node.value.replace(/\s+/gu, "");
-					for (const char of value) start = tokenIndex(ctx, char, start) + 1;
-					start = skipSpaces(ctx.code, start);
-					node.value = ctx.code.slice(node.position.start.offset, start);
-				}
-			}
-			if (node.position.end) node.position.end.offset = start;
-		} else if (node.type === "expression") {
-			start = node.position.start.offset = tokenIndex(ctx, "{", start);
-			start += 1;
-		} else if (node.type === "doctype") {
-			if (!node.position) node.position = {
-				start: {},
-				end: {}
-			};
-			if (!node.position.end) node.position.end = {};
-			start = node.position.start.offset = tokenIndex(ctx, "<!", start);
-			start += 2;
-			start = node.position.end.offset = ctx.code.indexOf(">", start) + 1;
-		} else if (node.type === "root") {}
-	}, (node, [parent]) => {
-		if (node.type === "attribute") {
-			const attributes = parent.attributes;
-			if (attributes[attributes.length - 1] === node) start = calcStartTagEndOffset(parent, ctx);
-		} else if (node.type === "expression") start = tokenIndex(ctx, "}", start) + 1;
-		else if (node.type === "fragment" || node.type === "element" || node.type === "component" || node.type === "custom-element") {
-			if (!getSelfClosingTag(node, ctx)) {
-				const closeTagStart = tokenIndexSafe(ctx.code, `</${node.name}`, start);
-				if (closeTagStart != null) {
-					start = closeTagStart + 2 + node.name.length;
-					start = tokenIndex(ctx, ">", start) + 1;
-				}
-			}
-		} else return;
-		if (node.position.end) node.position.end.offset = start;
-	});
-}
-/**
-* Fix locations
-*/
-function fixLocationForAttr(node, ctx, start) {
-	if (node.kind === "empty") node.position.start.offset = tokenIndex(ctx, node.name, start);
-	else if (node.kind === "quoted") node.position.start.offset = tokenIndex(ctx, node.name, start);
-	else if (node.kind === "expression") node.position.start.offset = tokenIndex(ctx, node.name, start);
-	else if (node.kind === "shorthand") node.position.start.offset = tokenIndex(ctx, "{", start);
-	else if (node.kind === "spread") node.position.start.offset = tokenIndex(ctx, "{", start);
-	else if (node.kind === "template-literal") node.position.start.offset = tokenIndex(ctx, node.name, start);
-	else throw new ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
-}
-/**
-* Get token index
-*/
-function tokenIndex(ctx, token, position) {
-	const index = tokenIndexSafe(ctx.code, token, position);
-	if (index == null) {
-		const start = token.trim() === token ? skipSpaces(ctx.code, position) : position;
-		throw new ParseError(`Unknown token at ${start}, expected: ${JSON.stringify(token)}, actual: ${JSON.stringify(ctx.code.slice(start, start + 10))}`, start, ctx);
+* Normalize compiler byte offsets to JavaScript string indices.
+*
+* `@astrojs/compiler-rs` reports `start`/`end` as UTF-8 byte offsets. ESLint
+* `range`, `Context`, and JavaScript string slicing all use UTF-16 code-unit
+* indexes. Those values are the same for ASCII, but diverge as soon as a
+* multibyte character appears before or inside a node. For example, the raw
+* compiler offset after `"あ"` is 3, while the JavaScript index is 1.
+*
+* Keep this conversion in the parse phase so downstream code does not need to
+* know which compiler produced the AST or remember to remap every lookup.
+*/
+function normalizeLocations(result, code, ctx) {
+	const byteOffsetToIndex = buildByteOffsetToIndexMap(code);
+	remapNodeLocations(result.ast, byteOffsetToIndex);
+	for (const diagnostic of result.diagnostics || []) for (const label of diagnostic.labels || []) {
+		label.start = byteOffsetToIndex(label.start);
+		label.end = byteOffsetToIndex(label.end);
+		const loc = ctx.getLocFromIndex(label.start);
+		label.line = loc.line;
+		label.column = loc.column;
+	}
+}
+/**
+* Remap start/end properties on a compiler AST subtree.
+*
+* The compiler AST contains ESTree-compatible JavaScript nodes nested inside
+* Astro nodes. Walking generically keeps the location fix independent from the
+* exact node shape and prevents future compiler node additions from bypassing
+* the normalization.
+*/
+function remapNodeLocations(value, byteOffsetToIndex, seen = /* @__PURE__ */ new Set()) {
+	if (!value || typeof value !== "object") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		for (const child of value) remapNodeLocations(child, byteOffsetToIndex, seen);
+		return;
 	}
-	return index;
+	const node = value;
+	if (typeof node.start === "number") node.start = byteOffsetToIndex(node.start);
+	if (typeof node.end === "number") node.end = byteOffsetToIndex(node.end);
+	for (const child of Object.values(node)) remapNodeLocations(child, byteOffsetToIndex, seen);
+}
+/**
+* Build a mapper from compiler byte offsets to JavaScript string indices.
+*
+* The table records both coordinates at each source character boundary. The
+* returned function can then translate any compiler offset with a binary
+* search. If the offset falls between boundaries, it returns the previous
+* JavaScript index; this keeps error locations stable even if the compiler
+* points into a multibyte character boundary.
+*/
+function buildByteOffsetToIndexMap(source) {
+	const byteOffsets = [0];
+	const codeUnitOffsets = [0];
+	let byteOffset = 0;
+	for (let index = 0; index < source.length;) {
+		const codePoint = source.codePointAt(index);
+		const nextIndex = index + (codePoint > 65535 ? 2 : 1);
+		byteOffset += getUTF8ByteLength(codePoint);
+		byteOffsets.push(byteOffset);
+		codeUnitOffsets.push(nextIndex);
+		index = nextIndex;
+	}
+	return (offset) => {
+		let low = 0;
+		let high = byteOffsets.length - 1;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const value = byteOffsets[mid];
+			if (value === offset) return codeUnitOffsets[mid];
+			if (value < offset) low = mid + 1;
+			else high = mid - 1;
+		}
+		return codeUnitOffsets[Math.max(high, 0)] ?? 0;
+	};
 }
-/**
-* Get token index
-*/
-function tokenIndexSafe(string, token, position) {
-	const index = token.trim() === token ? skipSpaces(string, position) : position;
-	if (string.startsWith(token, index)) return index;
-	return null;
+/** Get the UTF-8 byte length for a Unicode code point. */
+function getUTF8ByteLength(codePoint) {
+	if (codePoint <= 127) return 1;
+	if (codePoint <= 2047) return 2;
+	if (codePoint <= 65535) return 3;
+	return 4;
 }
 //#endregion
 //#region src/parser/lru-cache.ts
 var LruCache = class extends Map {
+	capacity;
 	constructor(capacity) {
 		super();
 		this.capacity = capacity;
@@ -2134,64 +1877,22 @@ function parseTemplate$1(code, filePath) {
 	const cache = lruCache.get(code);
 	if (cache) return cache;
 	const ctx = new Context(code, filePath);
-	const normalized = ctx.locs.getNormalizedLineFeed();
-	const ctxForAstro = normalized.needRemap ? new Context(normalized.code, filePath) : ctx;
 	try {
-		const result = parse(normalized?.code ?? code, ctxForAstro);
-		if (normalized.needRemap) {
-			remap(result, normalized, code, ctxForAstro);
-			ctx.originalAST = ctxForAstro.originalAST;
-		}
 		const templateResult = {
-			result,
+			result: parse$1(code, ctx),
 			context: ctx
 		};
 		lruCache.set(code, templateResult);
 		return templateResult;
 	} catch (e) {
 		if (typeof e.pos === "number") {
-			const err = new ParseError(e.message, normalized?.remapIndex(e.pos), ctx);
+			const err = new ParseError(e.message, e.pos, ctx);
 			err.astroCompilerError = e;
 			throw err;
 		}
 		throw e;
 	}
 }
-/** Remap */
-function remap(result, normalized, originalCode, ctxForAstro) {
-	const remapDataMap = /* @__PURE__ */ new Map();
-	walk(result.ast, normalized.code, (node) => {
-		const start = normalized.remapIndex(node.position.start.offset);
-		let end, value;
-		if (node.position.end) {
-			end = normalized.remapIndex(node.position.end.offset);
-			if (node.position.start.offset === start && node.position.end.offset === end) return;
-		}
-		if (node.type === "text") value = originalCode.slice(start, normalized.remapIndex(getEndOffset(node, ctxForAstro)));
-		else if (node.type === "comment") value = originalCode.slice(start + 4, normalized.remapIndex(getEndOffset(node, ctxForAstro)) - 3);
-		else if (node.type === "attribute") {
-			if (node.kind !== "empty" && node.kind !== "shorthand" && node.kind !== "spread") {
-				let valueStart = normalized.remapIndex(calcAttributeValueStartOffset(node, ctxForAstro));
-				let valueEnd = normalized.remapIndex(calcAttributeEndOffset(node, ctxForAstro));
-				if (node.kind !== "quoted" || originalCode[valueStart] === "\"" || originalCode[valueStart] === "'") {
-					valueStart++;
-					valueEnd--;
-				}
-				value = originalCode.slice(valueStart, valueEnd);
-			}
-		}
-		remapDataMap.set(node, {
-			start,
-			end,
-			value
-		});
-	}, (_node) => {});
-	for (const [node, remapData] of remapDataMap) {
-		node.position.start.offset = remapData.start;
-		if (node.position.end) node.position.end.offset = remapData.end;
-		if (node.type === "text" || node.type === "comment" || node.type === "attribute" && node.kind !== "empty" && node.kind !== "shorthand" && node.kind !== "spread") node.value = remapData.value;
-	}
-}
 //#endregion
 //#region src/context/resolve-parser/espree.ts
 let espreeCache = null;
@@ -2239,8 +1940,9 @@ function getParser(attrs, parser) {
 //#region src/context/parser-options.ts
 const TS_PARSER_NAMES = ["@typescript-eslint/parser", "typescript-eslint-parser-for-extra-files"];
 var ParserOptionsContext = class {
+	parserOptions;
+	state = {};
 	constructor(options) {
-		this.state = {};
 		const parserOptions = {
 			ecmaVersion: 2020,
 			sourceType: "module",
@@ -2397,11 +2099,8 @@ function parseTemplate(code) {
 	const parsed = parseTemplate$1(code);
 	return {
 		result: parsed.result,
-		getEndOffset: (node) => getEndOffset(node, parsed.context),
-		calcAttributeValueStartOffset: (node) => calcAttributeValueStartOffset(node, parsed.context),
-		calcAttributeEndOffset: (node) => calcAttributeEndOffset(node, parsed.context),
 		walk(parent, enter, leave) {
-			walk(parent, code, enter, leave || (() => {}));
+			walk(parent, enter, leave);
 		},
 		getLocFromIndex: (index) => parsed.context.getLocFromIndex(index),
 		getIndexFromLoc: (loc) => parsed.context.locs.getIndexFromLoc(loc)
@@ -2413,7 +2112,7 @@ var ast_exports = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region package.json
 var name = "astro-eslint-parser";
-var version = "2.1.0";
+var version = "3.0.0";
 //#endregion
 //#region src/meta.ts
 var meta_exports = /* @__PURE__ */ __exportAll({