svg-eslint-parser 0.0.5 → 0.0.6

package/dist/index.js

@@ -3,7 +3,7 @@ import { unionWith } from "eslint-visitor-keys";
 
 //#region package.json
 var name$1 = "svg-eslint-parser";
-var version = "0.0.5";
+var version = "0.0.6";
 
 //#endregion
 //#region src/meta.ts
@@ -71,76 +71,72 @@ const RE_INCOMPLETE_CLOSING_TAG = /<\/[^>]+$/;
 
 //#endregion
 //#region src/constants/nodeTypes.ts
-let NodeTypes = /* @__PURE__ */ function(NodeTypes$1) {
-	NodeTypes$1["Attribute"] = "Attribute";
-	NodeTypes$1["AttributeKey"] = "AttributeKey";
-	NodeTypes$1["AttributeValue"] = "AttributeValue";
-	NodeTypes$1["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
-	NodeTypes$1["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
-	NodeTypes$1["CloseTag"] = "CloseTag";
-	NodeTypes$1["Comment"] = "Comment";
-	NodeTypes$1["CommentClose"] = "CommentClose";
-	NodeTypes$1["CommentContent"] = "CommentContent";
-	NodeTypes$1["CommentOpen"] = "CommentOpen";
-	NodeTypes$1["Doctype"] = "Doctype";
-	NodeTypes$1["DoctypeAttribute"] = "DoctypeAttribute";
-	NodeTypes$1["DoctypeAttributeValue"] = "DoctypeAttributeValue";
-	NodeTypes$1["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
-	NodeTypes$1["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
-	NodeTypes$1["DoctypeClose"] = "DoctypeClose";
-	NodeTypes$1["DoctypeOpen"] = "DoctypeOpen";
-	NodeTypes$1["Document"] = "Document";
-	NodeTypes$1["OpenTagEnd"] = "OpenTagEnd";
-	NodeTypes$1["OpenTagStart"] = "OpenTagStart";
-	NodeTypes$1["Program"] = "Program";
-	NodeTypes$1["Tag"] = "Tag";
-	NodeTypes$1["Text"] = "Text";
-	NodeTypes$1["XMLDeclaration"] = "XMLDeclaration";
-	NodeTypes$1["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-	NodeTypes$1["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-	NodeTypes$1["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-	NodeTypes$1["XMLDeclarationAttributeValueWrapperEnd"] = "XMLDeclarationAttributeValueWrapperEnd";
-	NodeTypes$1["XMLDeclarationAttributeValueWrapperStart"] = "XMLDeclarationAttributeValueWrapperStart";
-	NodeTypes$1["XMLDeclarationClose"] = "XMLDeclarationClose";
-	NodeTypes$1["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-	return NodeTypes$1;
+let NodeTypes = /* @__PURE__ */ function(NodeTypes) {
+	NodeTypes["Attribute"] = "Attribute";
+	NodeTypes["AttributeKey"] = "AttributeKey";
+	NodeTypes["AttributeValue"] = "AttributeValue";
+	NodeTypes["Comment"] = "Comment";
+	NodeTypes["Doctype"] = "Doctype";
+	NodeTypes["DoctypeAttribute"] = "DoctypeAttribute";
+	NodeTypes["DoctypeAttributeValue"] = "DoctypeAttributeValue";
+	NodeTypes["Document"] = "Document";
+	NodeTypes["Error"] = "Error";
+	NodeTypes["Program"] = "Program";
+	NodeTypes["Tag"] = "Tag";
+	NodeTypes["Text"] = "Text";
+	NodeTypes["XMLDeclaration"] = "XMLDeclaration";
+	NodeTypes["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
+	NodeTypes["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
+	NodeTypes["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
+	return NodeTypes;
 }({});
 
 //#endregion
 //#region src/constants/tokenTypes.ts
-let TokenTypes = /* @__PURE__ */ function(TokenTypes$1) {
-	TokenTypes$1["Attribute"] = "Attribute";
-	TokenTypes$1["AttributeAssignment"] = "AttributeAssignment";
-	TokenTypes$1["AttributeKey"] = "AttributeKey";
-	TokenTypes$1["AttributeValue"] = "AttributeValue";
-	TokenTypes$1["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
-	TokenTypes$1["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
-	TokenTypes$1["CloseTag"] = "CloseTag";
-	TokenTypes$1["Comment"] = "Comment";
-	TokenTypes$1["CommentClose"] = "CommentClose";
-	TokenTypes$1["CommentContent"] = "CommentContent";
-	TokenTypes$1["CommentOpen"] = "CommentOpen";
-	TokenTypes$1["Doctype"] = "Doctype";
-	TokenTypes$1["DoctypeAttributeValue"] = "DoctypeAttributeValue";
-	TokenTypes$1["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
-	TokenTypes$1["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
-	TokenTypes$1["DoctypeClose"] = "DoctypeClose";
-	TokenTypes$1["DoctypeOpen"] = "DoctypeOpen";
-	TokenTypes$1["Document"] = "Document";
-	TokenTypes$1["OpenTagEnd"] = "OpenTagEnd";
-	TokenTypes$1["OpenTagStart"] = "OpenTagStart";
-	TokenTypes$1["Program"] = "Program";
-	TokenTypes$1["Tag"] = "Tag";
-	TokenTypes$1["Text"] = "Text";
-	TokenTypes$1["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-	TokenTypes$1["XMLDeclarationAttributeAssignment"] = "XMLDeclarationAttributeAssignment";
-	TokenTypes$1["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-	TokenTypes$1["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-	TokenTypes$1["XMLDeclarationAttributeValueWrapperEnd"] = "XMLDeclarationAttributeValueWrapperEnd";
-	TokenTypes$1["XMLDeclarationAttributeValueWrapperStart"] = "XMLDeclarationAttributeValueWrapperStart";
-	TokenTypes$1["XMLDeclarationClose"] = "XMLDeclarationClose";
-	TokenTypes$1["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-	return TokenTypes$1;
+let TokenTypes = /* @__PURE__ */ function(TokenTypes) {
+	/**
+	* @pg Content tokens
+	*/
+	TokenTypes["Text"] = "Text";
+	/**
+	* @pg Attribute tokens
+	*/
+	TokenTypes["AttributeAssignment"] = "AttributeAssignment";
+	TokenTypes["AttributeKey"] = "AttributeKey";
+	TokenTypes["AttributeValue"] = "AttributeValue";
+	TokenTypes["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
+	TokenTypes["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
+	/**
+	* @pg Doctype tokens
+	*/
+	TokenTypes["DoctypeAttributeValue"] = "DoctypeAttributeValue";
+	TokenTypes["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
+	TokenTypes["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
+	TokenTypes["DoctypeClose"] = "DoctypeClose";
+	TokenTypes["DoctypeOpen"] = "DoctypeOpen";
+	/**
+	* @pg Tag tokens
+	*/
+	TokenTypes["CloseTag"] = "CloseTag";
+	TokenTypes["OpenTagEnd"] = "OpenTagEnd";
+	TokenTypes["OpenTagStart"] = "OpenTagStart";
+	/**
+	* @pg Comment tokens
+	*/
+	TokenTypes["CommentClose"] = "CommentClose";
+	TokenTypes["CommentContent"] = "CommentContent";
+	TokenTypes["CommentOpen"] = "CommentOpen";
+	/**
+	* @pg XML Declaration tokens
+	*/
+	TokenTypes["XMLDeclarationAttributeAssignment"] = "XMLDeclarationAttributeAssignment";
+	TokenTypes["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
+	TokenTypes["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
+	TokenTypes["XMLDeclarationAttributeValueWrapperEnd"] = "XMLDeclarationAttributeValueWrapperEnd";
+	TokenTypes["XMLDeclarationAttributeValueWrapperStart"] = "XMLDeclarationAttributeValueWrapperStart";
+	TokenTypes["XMLDeclarationClose"] = "XMLDeclarationClose";
+	TokenTypes["XMLDeclarationOpen"] = "XMLDeclarationOpen";
+	return TokenTypes;
 }({});
 
 //#endregion
@@ -299,79 +295,152 @@ const SELF_CLOSING_ELEMENTS = new Set([
 
 //#endregion
 //#region src/constants/tokenizerContextTypes.ts
-let TokenizerContextTypes = /* @__PURE__ */ function(TokenizerContextTypes$1) {
-	TokenizerContextTypes$1["AttributeKey"] = "AttributeKey";
-	TokenizerContextTypes$1["Attributes"] = "Attributes";
-	TokenizerContextTypes$1["AttributeValue"] = "AttributeValue";
-	TokenizerContextTypes$1["AttributeValueBare"] = "AttributeValueBare";
-	TokenizerContextTypes$1["AttributeValueWrapped"] = "AttributeValueWrapped";
-	TokenizerContextTypes$1["CloseTag"] = "CloseTag";
-	TokenizerContextTypes$1["CommentClose"] = "CommentClose";
-	TokenizerContextTypes$1["CommentContent"] = "CommentContent";
-	TokenizerContextTypes$1["CommentOpen"] = "CommentOpen";
-	TokenizerContextTypes$1["Data"] = "Data";
-	TokenizerContextTypes$1["DoctypeAttributeBare"] = "DoctypeAttributeBare";
-	TokenizerContextTypes$1["DoctypeAttributes"] = "DoctypeAttributes";
-	TokenizerContextTypes$1["DoctypeAttributeWrapped"] = "DoctypeAttributeWrapped";
-	TokenizerContextTypes$1["DoctypeClose"] = "DoctypeClose";
-	TokenizerContextTypes$1["DoctypeOpen"] = "DoctypeOpen";
-	TokenizerContextTypes$1["OpenTagEnd"] = "OpenTagEnd";
-	TokenizerContextTypes$1["OpenTagStart"] = "OpenTagStart";
-	TokenizerContextTypes$1["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-	TokenizerContextTypes$1["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
-	TokenizerContextTypes$1["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-	TokenizerContextTypes$1["XMLDeclarationAttributeValueWrapped"] = "XMLDeclarationAttributeValueWrapped";
-	TokenizerContextTypes$1["XMLDeclarationClose"] = "XMLDeclarationClose";
-	TokenizerContextTypes$1["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-	return TokenizerContextTypes$1;
+let TokenizerContextTypes = /* @__PURE__ */ function(TokenizerContextTypes) {
+	TokenizerContextTypes["AttributeKey"] = "AttributeKey";
+	TokenizerContextTypes["Attributes"] = "Attributes";
+	TokenizerContextTypes["AttributeValue"] = "AttributeValue";
+	TokenizerContextTypes["AttributeValueBare"] = "AttributeValueBare";
+	TokenizerContextTypes["AttributeValueWrapped"] = "AttributeValueWrapped";
+	TokenizerContextTypes["CloseTag"] = "CloseTag";
+	TokenizerContextTypes["CommentClose"] = "CommentClose";
+	TokenizerContextTypes["CommentContent"] = "CommentContent";
+	TokenizerContextTypes["CommentOpen"] = "CommentOpen";
+	TokenizerContextTypes["Data"] = "Data";
+	TokenizerContextTypes["DoctypeAttributeBare"] = "DoctypeAttributeBare";
+	TokenizerContextTypes["DoctypeAttributes"] = "DoctypeAttributes";
+	TokenizerContextTypes["DoctypeAttributeWrapped"] = "DoctypeAttributeWrapped";
+	TokenizerContextTypes["DoctypeClose"] = "DoctypeClose";
+	TokenizerContextTypes["DoctypeOpen"] = "DoctypeOpen";
+	TokenizerContextTypes["OpenTagEnd"] = "OpenTagEnd";
+	TokenizerContextTypes["OpenTagStart"] = "OpenTagStart";
+	TokenizerContextTypes["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
+	TokenizerContextTypes["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
+	TokenizerContextTypes["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
+	TokenizerContextTypes["XMLDeclarationAttributeValueWrapped"] = "XMLDeclarationAttributeValueWrapped";
+	TokenizerContextTypes["XMLDeclarationClose"] = "XMLDeclarationClose";
+	TokenizerContextTypes["XMLDeclarationOpen"] = "XMLDeclarationOpen";
+	return TokenizerContextTypes;
 }({});
 
 //#endregion
 //#region src/constants/constructTreeContextTypes.ts
-let ConstructTreeContextTypes = /* @__PURE__ */ function(ConstructTreeContextTypes$1) {
-	ConstructTreeContextTypes$1["Attribute"] = "Attribute";
-	ConstructTreeContextTypes$1["Attributes"] = "Attributes";
-	ConstructTreeContextTypes$1["AttributeValue"] = "AttributeValue";
-	ConstructTreeContextTypes$1["Comment"] = "Comment";
-	ConstructTreeContextTypes$1["Doctype"] = "Doctype";
-	ConstructTreeContextTypes$1["DoctypeAttribute"] = "DoctypeAttribute";
-	ConstructTreeContextTypes$1["DoctypeAttributes"] = "DoctypeAttributes";
-	ConstructTreeContextTypes$1["Tag"] = "Tag";
-	ConstructTreeContextTypes$1["TagContent"] = "TagContent";
-	ConstructTreeContextTypes$1["TagName"] = "TagName";
-	ConstructTreeContextTypes$1["XMLDeclaration"] = "XMLDeclaration";
-	ConstructTreeContextTypes$1["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-	ConstructTreeContextTypes$1["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
-	ConstructTreeContextTypes$1["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-	return ConstructTreeContextTypes$1;
+let ConstructTreeContextTypes = /* @__PURE__ */ function(ConstructTreeContextTypes) {
+	ConstructTreeContextTypes["Attribute"] = "Attribute";
+	ConstructTreeContextTypes["Attributes"] = "Attributes";
+	ConstructTreeContextTypes["AttributeValue"] = "AttributeValue";
+	ConstructTreeContextTypes["Comment"] = "Comment";
+	ConstructTreeContextTypes["Doctype"] = "Doctype";
+	ConstructTreeContextTypes["DoctypeAttribute"] = "DoctypeAttribute";
+	ConstructTreeContextTypes["DoctypeAttributes"] = "DoctypeAttributes";
+	ConstructTreeContextTypes["Tag"] = "Tag";
+	ConstructTreeContextTypes["TagContent"] = "TagContent";
+	ConstructTreeContextTypes["TagName"] = "TagName";
+	ConstructTreeContextTypes["XMLDeclaration"] = "XMLDeclaration";
+	ConstructTreeContextTypes["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
+	ConstructTreeContextTypes["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
+	ConstructTreeContextTypes["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
+	return ConstructTreeContextTypes;
 }({});
 
+//#endregion
+//#region src/utils/cloneNode.ts
+/**
+* Deep clone a node, removing parent references
+* @param node - Node to clone
+* @returns Cloned node
+*/
+function cloneNode(node) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return node.map((item) => cloneNode(item));
+	const cloned = {};
+	for (const key in node) {
+		if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+		if (key === "parentRef" || key === "parent") continue;
+		const value = node[key];
+		if (value && typeof value === "object") if (Array.isArray(value)) cloned[key] = value.map((item) => cloneNode(item));
+		else cloned[key] = cloneNode(value);
+		else cloned[key] = value;
+	}
+	return cloned;
+}
+/**
+* Deep clone a node, preserving parent references
+* @param node - Node to clone
+* @param parent - Parent node for the cloned node
+* @returns Cloned node with parent references
+*/
+function cloneNodeWithParent(node, parent) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return node.map((item) => cloneNodeWithParent(item));
+	const cloned = {};
+	for (const key in node) {
+		if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+		if (key === "parentRef" || key === "parent") continue;
+		const value = node[key];
+		if (value && typeof value === "object") if (Array.isArray(value)) cloned[key] = value.map((item) => cloneNodeWithParent(item, cloned));
+		else cloned[key] = cloneNodeWithParent(value, cloned);
+		else cloned[key] = value;
+	}
+	if (parent) cloned.parentRef = parent;
+	return cloned;
+}
+
 //#endregion
 //#region src/utils/firstLast.ts
+/**
+* Get the first element of an array
+* @param items - Array to get first element from
+* @returns First element of the array
+*/
 function first(items) {
 	return items[0];
 }
+/**
+* Get the last element of an array
+* @param items - Array to get last element from
+* @returns Last element of the array
+*/
 function last(items) {
 	return items[items.length - 1];
 }
 
 //#endregion
 //#region src/utils/cloneRange.ts
+/**
+* Create a shallow copy of a range tuple
+* @param range - Range tuple [start, end] to clone
+* @returns New range tuple with copied values
+*/
 function cloneRange(range) {
 	return [range[0], range[1]];
 }
 
 //#endregion
 //#region src/utils/initIfNone.ts
+/**
+* Initialize children array if it doesn't exist
+* @param node - Node to initialize
+* @param node.children - Children to set if none exist
+*/
 function initChildrenIfNone(node) {
 	if (!node.children) node.children = [];
 }
+/**
+* Initialize attributes array if it doesn't exist
+* @param node - Node to initialize
+* @param node.attributes - Attributes to set if none exist
+*/
 function initAttributesIfNone(node) {
 	if (!node.attributes) node.attributes = [];
 }
 
 //#endregion
 //#region src/utils/clearParent.ts
+/**
+* Recursively remove parent references from an AST
+* @param ast - The AST node to clean
+* @returns The cleaned AST with parentRef properties removed
+*/
 function clearParent(ast) {
 	const cleanAst = ast;
 	delete cleanAst.parentRef;
@@ -383,9 +452,21 @@ function clearParent(ast) {
 
 //#endregion
 //#region src/utils/getLineInfo.ts
+/**
+* Check if a character code represents a line break
+* @param code - Character code to check
+* @returns True if code is a newline character (LF, CR, LS, PS)
+*/
 function isNewLine(code) {
 	return code === 10 || code === 13 || code === 8232 || code === 8233;
 }
+/**
+* Find the next line break position in a string
+* @param code - String to search
+* @param from - Starting position
+* @param end - Ending position (default: string length)
+* @returns Index of next line break, or -1 if not found
+*/
 function nextLineBreak(code, from, end = code.length) {
 	for (let i = from; i < end; i++) {
 		const next = code.codePointAt(i);
@@ -394,6 +475,12 @@ function nextLineBreak(code, from, end = code.length) {
 	}
 	return -1;
 }
+/**
+* Get the line and column number for a position in source code
+* @param input - Source code string
+* @param offset - Character offset position
+* @returns Object with line (1-indexed) and column (0-indexed) information
+*/
 function getLineInfo(input, offset) {
 	for (let line = 1, cur = 0;;) {
 		const nextBreak = nextLineBreak(input, cur, offset);
@@ -406,14 +493,178 @@ function getLineInfo(input, offset) {
 	}
 }
 
+//#endregion
+//#region src/utils/nodeHelpers.ts
+/**
+* Filter nodes by a predicate function
+* @param node - Root node to filter from
+* @param predicate - Filter function
+* @returns Array of matching nodes
+*/
+function filterNodes(node, predicate) {
+	const results = [];
+	function traverse$1(currentNode) {
+		if (predicate(currentNode)) results.push(currentNode);
+		if ("children" in currentNode && Array.isArray(currentNode.children)) for (const child of currentNode.children) traverse$1(child);
+		if ("attributes" in currentNode && Array.isArray(currentNode.attributes)) for (const attr of currentNode.attributes) traverse$1(attr);
+	}
+	traverse$1(node);
+	return results;
+}
+/**
+* Map over all nodes in the AST
+* @param node - Root node to map from
+* @param mapper - Mapping function
+* @returns Transformed node
+*/
+function mapNodes(node, mapper) {
+	const mapped = mapper(node);
+	if ("children" in mapped && Array.isArray(mapped.children)) mapped.children = mapped.children.map((child) => mapNodes(child, mapper));
+	if ("attributes" in mapped && Array.isArray(mapped.attributes)) mapped.attributes = mapped.attributes.map((attr) => mapNodes(attr, mapper));
+	return mapped;
+}
+/**
+* Get all parent nodes from a node up to the root
+* @param node - Starting node
+* @returns Array of parent nodes (from immediate parent to root)
+*/
+function getParentChain(node) {
+	const chain = [];
+	let current = node.parentRef || node.parent;
+	while (current) {
+		chain.push(current);
+		current = current.parentRef || current.parent;
+	}
+	return chain;
+}
+/**
+* Get the depth of a node in the AST (distance from root)
+* @param node - Node to measure
+* @returns Depth level (root = 0)
+*/
+function getNodeDepth(node) {
+	let depth = 0;
+	let current = node.parentRef || node.parent;
+	while (current) {
+		depth++;
+		current = current.parentRef || current.parent;
+	}
+	return depth;
+}
+/**
+* Count total number of nodes in the AST
+* @param node - Root node
+* @returns Total node count
+*/
+function countNodes(node) {
+	let count = 1;
+	if ("children" in node && Array.isArray(node.children)) for (const child of node.children) count += countNodes(child);
+	if ("attributes" in node && Array.isArray(node.attributes)) for (const attr of node.attributes) count += countNodes(attr);
+	return count;
+}
+
+//#endregion
+//#region src/utils/traverseAST.ts
+/**
+* Traverse the AST with a visitor pattern
+* @param node - Root node to traverse from
+* @param visitor - Visitor object with enter/leave hooks
+* @param parent - Parent node (used internally)
+*/
+function traverseAST(node, visitor, parent = null) {
+	let shouldTraverseChildren = true;
+	if (visitor.enter) {
+		if (visitor.enter(node, parent) === false) shouldTraverseChildren = false;
+	}
+	if (shouldTraverseChildren) {
+		if ("children" in node && Array.isArray(node.children)) for (const child of node.children) traverseAST(child, visitor, node);
+		if ("attributes" in node && Array.isArray(node.attributes)) for (const attr of node.attributes) traverseAST(attr, visitor, node);
+	}
+	if (visitor.leave) visitor.leave(node, parent);
+}
+/**
+* Simple traversal function that calls a callback for each node
+* @param node - Root node to traverse from
+* @param callback - Function to call for each node
+*/
+function walkAST(node, callback) {
+	traverseAST(node, { enter: callback });
+}
+
 //#endregion
 //#region src/utils/isWhitespace.ts
+/**
+* Check if a character is whitespace (space, newline, return, or tab)
+* @param char - Character to check
+* @returns True if character is whitespace
+*/
 function isWhitespace(char) {
 	return char === SPECIAL_CHAR.space || char === SPECIAL_CHAR.newline || char === SPECIAL_CHAR.return || char === SPECIAL_CHAR.tab;
 }
 
+//#endregion
+//#region src/utils/validateNode.ts
+/**
+* Validate if a node matches its expected structure
+* @param node - Node to validate
+* @returns True if node is valid
+*/
+function validateNode(node) {
+	if (!node || typeof node !== "object") return false;
+	if (!("type" in node) || !("range" in node) || !("loc" in node)) return false;
+	if (!Array.isArray(node.range) || node.range.length !== 2 || typeof node.range[0] !== "number" || typeof node.range[1] !== "number") return false;
+	if (!node.loc || !node.loc.start || !node.loc.end || typeof node.loc.start.line !== "number" || typeof node.loc.start.column !== "number" || typeof node.loc.end.line !== "number" || typeof node.loc.end.column !== "number") return false;
+	switch (node.type) {
+		case NodeTypes.Tag: return validateTagNode(node);
+		case NodeTypes.Attribute: return validateAttributeNode(node);
+		case NodeTypes.Text: return validateTextNode(node);
+		case NodeTypes.Comment: return validateCommentNode(node);
+		case NodeTypes.Document: return validateDocumentNode(node);
+		case NodeTypes.Doctype: return validateDoctypeNode(node);
+		default: return true;
+	}
+}
+function validateTagNode(node) {
+	if (!("name" in node) || typeof node.name !== "string") return false;
+	if ("children" in node && !Array.isArray(node.children)) return false;
+	if ("attributes" in node && !Array.isArray(node.attributes)) return false;
+	return true;
+}
+function validateAttributeNode(node) {
+	if ("key" in node && node.key !== void 0 && typeof node.key !== "object") return false;
+	if ("value" in node && node.value !== void 0 && typeof node.value !== "object") return false;
+	return true;
+}
+function validateTextNode(node) {
+	return "value" in node && typeof node.value === "string";
+}
+function validateCommentNode(node) {
+	return "content" in node && typeof node.content === "string";
+}
+function validateDocumentNode(node) {
+	return "children" in node && Array.isArray(node.children);
+}
+function validateDoctypeNode(node) {
+	if ("attributes" in node && !Array.isArray(node.attributes)) return false;
+	return true;
+}
+/**
+* Check if a node is of a specific type with type guard
+* @param node - Node to check
+* @param type - Expected node type
+* @returns True if node is of the specified type
+*/
+function isNodeType(node, type) {
+	return node.type === type;
+}
+
 //#endregion
 //#region src/utils/cloneLocation.ts
+/**
+* Create a shallow copy of a source location object
+* @param loc - Source location to clone
+* @returns Cloned location with new start and end objects
+*/
 function cloneLocation(loc) {
 	return {
 		start: {
@@ -429,6 +680,11 @@ function cloneLocation(loc) {
 
 //#endregion
 //#region src/utils/updateNodeEnd.ts
+/**
+* Update a node's end position and location based on a token
+* @param node - Node to update
+* @param token - Token containing the new end position
+*/
 function updateNodeEnd(node, token) {
 	node.range[1] = token.range[1];
 	node.loc.end = { ...token.loc.end };
@@ -436,6 +692,11 @@ function updateNodeEnd(node, token) {
 
 //#endregion
 //#region src/utils/createNodeFrom.ts
+/**
+* Create a node object from a token, copying essential properties
+* @param token - Token to convert to a node
+* @returns Object with type, value, location, and range from the token
+*/
 function createNodeFrom(token) {
 	const loc = cloneLocation(token.loc);
 	const range = cloneRange(token.range);
@@ -447,6 +708,45 @@ function createNodeFrom(token) {
 	};
 }
 
+//#endregion
+//#region src/utils/findNodeByType.ts
+/**
+* Find all nodes of a specific type in the AST
+* @param node - Root node to search from
+* @param type - Node type to search for
+* @returns Array of matching nodes
+*/
+function findNodeByType(node, type) {
+	const results = [];
+	function traverse$1(currentNode) {
+		if (currentNode.type === type) results.push(currentNode);
+		if ("children" in currentNode && Array.isArray(currentNode.children)) for (const child of currentNode.children) traverse$1(child);
+		if ("attributes" in currentNode && Array.isArray(currentNode.attributes)) for (const attr of currentNode.attributes) traverse$1(attr);
+	}
+	traverse$1(node);
+	return results;
+}
+/**
+* Find the first node of a specific type in the AST
+* @param node - Root node to search from
+* @param type - Node type to search for
+* @returns First matching node or undefined
+*/
+function findFirstNodeByType(node, type) {
+	function traverse$1(currentNode) {
+		if (currentNode.type === type) return currentNode;
+		if ("children" in currentNode && Array.isArray(currentNode.children)) for (const child of currentNode.children) {
+			const result = traverse$1(child);
+			if (result) return result;
+		}
+		if ("attributes" in currentNode && Array.isArray(currentNode.attributes)) for (const attr of currentNode.attributes) {
+			const result = traverse$1(attr);
+			if (result) return result;
+		}
+	}
+	return traverse$1(node);
+}
+
 //#endregion
 //#region src/utils/getLastAttribute.ts
 function getLastAttribute(state) {
@@ -456,6 +756,12 @@ function getLastAttribute(state) {
 
 //#endregion
 //#region src/utils/parseOpenTagName.ts
+/**
+* Parse the tag name from an opening tag token content
+* @param openTagStartTokenContent - Raw opening tag content (e.g., "<svg ")
+* @returns Extracted and normalized tag name in lowercase
+* @throws {Error} if content doesn't match opening tag pattern
+*/
 function parseOpenTagName(openTagStartTokenContent) {
 	const match = openTagStartTokenContent.match(RE_OPEN_TAG_NAME);
 	if (match === null) throw new Error(`Unable to parse open tag name.\n${openTagStartTokenContent} does not match pattern of opening tag.`);
@@ -464,6 +770,12 @@ function parseOpenTagName(openTagStartTokenContent) {
 
 //#endregion
 //#region src/utils/parseCloseTagName.ts
+/**
+* Parse the tag name from a closing tag token content
+* @param closeTagTokenContent - Raw closing tag content (e.g., "</svg>")
+* @returns Extracted and normalized tag name in lowercase
+* @throws {Error} if content doesn't match closing tag pattern
+*/
 function parseCloseTagName(closeTagTokenContent) {
 	const match = closeTagTokenContent.match(RE_CLOSE_TAG_NAME);
 	if (match === null) throw new Error(`Unable to parse close tag name.\n${closeTagTokenContent} does not match pattern of closing tag.`);
@@ -472,6 +784,12 @@ function parseCloseTagName(closeTagTokenContent) {
 
 //#endregion
 //#region src/utils/calculateTokenLocation.ts
+/**
+* Calculate the source location of a token based on its character range
+* @param source - Source code string
+* @param range - Character range [start, end]
+* @returns Object with start and end line/column information
+*/
 function calculateTokenLocation(source, range) {
 	return {
 		start: getLineInfo(source, range[0]),
@@ -481,6 +799,13 @@ function calculateTokenLocation(source, range) {
 
 //#endregion
 //#region src/utils/calculateTokenCharactersRange.ts
+/**
+* Calculate the character range of a token based on tokenizer state
+* @param state - Current tokenizer state
+* @param options - Configuration options
+* @param options.keepBuffer - Whether to include decision buffer in the range
+* @returns Array containing [startPosition, endPosition + 1]
+*/
 function calculateTokenCharactersRange(state, options) {
 	const startPosition = state.sourceCode.index() - (state.accumulatedContent.length() - 1) - state.decisionBuffer.length();
 	let endPosition;
@@ -491,6 +816,13 @@ function calculateTokenCharactersRange(state, options) {
 
 //#endregion
 //#region src/utils/calculateTokenPosition.ts
+/**
+* Calculate both character range and source location of a token
+* @param state - Current tokenizer state
+* @param options - Configuration options
+* @param options.keepBuffer - Whether to include decision buffer in the range
+* @returns Object with range and location (loc) properties
+*/
 function calculateTokenPosition(state, options) {
 	const range = calculateTokenCharactersRange(state, options);
 	return {
@@ -500,453 +832,657 @@ function calculateTokenPosition(state, options) {
 }
 
 //#endregion
-//#region src/constructor/handlers/tag.ts
-var tag_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$13 });
-const ATTRIBUTE_START_TOKENS$2 = new Set([TokenTypes.AttributeKey, TokenTypes.AttributeAssignment]);
-function construct$13(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) return handleOpenTagStart$1(state, token);
-	if (ATTRIBUTE_START_TOKENS$2.has(token.type)) return handleAttributeStart$1(state);
-	if (token.type === TokenTypes.OpenTagEnd) return handleOpenTagEnd$2(state, token);
-	if (token.type === TokenTypes.CloseTag) return handleCloseTag$1(state, token);
-	state.caretPosition++;
-	return state;
-}
-function handleOpenTagStart$1(state, token) {
-	state.currentNode.openStart = createNodeFrom(token);
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.TagName
-	};
-	return state;
-}
-function handleAttributeStart$1(state) {
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.Attributes
-	};
-	return state;
-}
-function handleOpenTagEnd$2(state, token) {
-	const tagName = state.currentNode.name;
-	state.currentNode.openEnd = createNodeFrom(token);
-	updateNodeEnd(state.currentNode, token);
-	if (tagName && SELF_CLOSING_ELEMENTS.has(tagName) && state.currentNode.openEnd.value === "/>") {
-		state.currentNode.selfClosing = true;
-		state.currentNode = state.currentNode.parentRef;
-		state.currentContext = state.currentContext.parentRef;
-		state.caretPosition++;
+//#region src/constructor/handlerFactory.ts
+/**
+* Creates a dispatch function from handler configurations
+* @param handlers - Array of handler configurations
+* @param defaultHandler - Optional default handler for unmatched tokens
+* @returns A function that dispatches tokens to appropriate handlers
+*/
+function createTokenDispatcher(handlers, defaultHandler) {
+	return (token, state) => {
+		for (const config of handlers) if (config.tokenType instanceof Set ? config.tokenType.has(token.type) : config.tokenType === token.type) return config.handler(token, state);
+		if (defaultHandler) return defaultHandler(token, state);
 		return state;
-	}
-	state.currentNode.selfClosing = false;
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.TagContent
 	};
-	state.caretPosition++;
-	return state;
 }
-function handleCloseTag$1(state, token) {
-	state.currentNode.close = createNodeFrom(token);
-	updateNodeEnd(state.currentNode, token);
-	state.currentNode = state.currentNode.parentRef;
-	state.currentContext = state.currentContext.parentRef;
+
+//#endregion
+//#region src/constructor/handlers/tag.ts
+var tag_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$13 });
+const ATTRIBUTE_START_TOKENS$3 = new Set([TokenTypes.AttributeKey, TokenTypes.AttributeAssignment]);
+const dispatch$13 = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.OpenTagStart,
+		handler(token, state) {
+			state.currentNode.openStart = createNodeFrom(token);
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.TagName
+			};
+			return state;
+		}
+	},
+	{
+		tokenType: ATTRIBUTE_START_TOKENS$3,
+		handler(_, state) {
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.Attributes
+			};
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.OpenTagEnd,
+		handler(token, state) {
+			const tagName = state.currentNode.name;
+			state.currentNode.openEnd = createNodeFrom(token);
+			updateNodeEnd(state.currentNode, token);
+			if (tagName && SELF_CLOSING_ELEMENTS.has(tagName) && state.currentNode.openEnd.value === "/>") {
+				state.currentNode.selfClosing = true;
+				state.currentNode = state.currentNode.parentRef;
+				state.currentContext = state.currentContext.parentRef;
+				state.caretPosition++;
+				return state;
+			}
+			state.currentNode.selfClosing = false;
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.TagContent
+			};
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.CloseTag,
+		handler(token, state) {
+			state.currentNode.close = createNodeFrom(token);
+			updateNodeEnd(state.currentNode, token);
+			state.currentNode = state.currentNode.parentRef;
+			state.currentContext = state.currentContext.parentRef;
+			state.caretPosition++;
+			return state;
+		}
+	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
+});
+function construct$13(token, state) {
+	return dispatch$13(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/comment.ts
 var comment_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$12 });
+const dispatch$12 = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.CommentOpen,
+		handler(_, state) {
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.CommentContent,
+		handler(token, state) {
+			state.currentNode.content = token.value;
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.CommentClose,
+		handler(token, state) {
+			updateNodeEnd(state.currentNode, token);
+			state.currentNode = state.currentNode.parentRef;
+			state.currentContext = state.currentContext.parentRef;
+			state.caretPosition++;
+			return state;
+		}
+	}
+]);
 function construct$12(token, state) {
-	if (token.type === TokenTypes.CommentOpen) return handleCommentOpen$1(state, token);
-	if (token.type === TokenTypes.CommentContent) return handleCommentContent(state, token);
-	if (token.type === TokenTypes.CommentClose) return handleCommentClose(state, token);
-	return state;
-}
-function handleCommentOpen$1(state, token) {
-	state.currentNode.open = createNodeFrom(token);
-	state.caretPosition++;
-	return state;
-}
-function handleCommentContent(state, token) {
-	state.currentNode.value = createNodeFrom(token);
-	state.caretPosition++;
-	return state;
-}
-function handleCommentClose(state, token) {
-	state.currentNode.close = createNodeFrom(token);
-	updateNodeEnd(state.currentNode, token);
-	state.currentNode = state.currentNode.parentRef;
-	state.currentContext = state.currentContext.parentRef;
-	state.caretPosition++;
-	return state;
+	return dispatch$12(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/doctype.ts
 var doctype_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$11 });
 const ATTRIBUTES_START_TOKENS = new Set([TokenTypes.DoctypeAttributeWrapperStart, TokenTypes.DoctypeAttributeValue]);
-function construct$11(token, state) {
-	if (token.type === TokenTypes.DoctypeOpen) return handleDoctypeOpen$1(state, token);
-	if (token.type === TokenTypes.DoctypeClose) return handleDoctypeClose$2(state, token);
-	if (ATTRIBUTES_START_TOKENS.has(token.type)) return handleDoctypeAttributes(state);
-	state.caretPosition++;
-	return state;
-}
-function handleDoctypeOpen$1(state, token) {
-	state.currentNode.open = createNodeFrom(token);
-	state.caretPosition++;
-	return state;
-}
-function handleDoctypeClose$2(state, token) {
-	state.currentNode.close = createNodeFrom(token);
-	updateNodeEnd(state.currentNode, token);
-	state.currentNode = state.currentNode.parentRef;
-	state.currentContext = state.currentContext.parentRef;
+const dispatch$11 = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.DoctypeOpen,
+		handler(token, state) {
+			state.currentNode.open = createNodeFrom(token);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.DoctypeClose,
+		handler(token, state) {
+			state.currentNode.close = createNodeFrom(token);
+			updateNodeEnd(state.currentNode, token);
+			state.currentNode = state.currentNode.parentRef;
+			state.currentContext = state.currentContext.parentRef;
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: ATTRIBUTES_START_TOKENS,
+		handler(_, state) {
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.DoctypeAttributes
+			};
+			return state;
+		}
+	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleDoctypeAttributes(state) {
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.DoctypeAttributes
-	};
-	return state;
+});
+function construct$11(token, state) {
+	return dispatch$11(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/tagName.ts
 var tagName_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$10 });
-function construct$10(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) handleTagOpenStart$4(state, token);
+const dispatch$10 = createTokenDispatcher([{
+	tokenType: TokenTypes.OpenTagStart,
+	handler(token, state) {
+		state.currentNode.name = parseOpenTagName(token.value);
+		state.currentContext = state.currentContext.parentRef;
+		state.caretPosition++;
+		return state;
+	}
+}], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleTagOpenStart$4(state, token) {
-	state.currentNode.name = parseOpenTagName(token.value);
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct$10(token, state) {
+	return dispatch$10(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/attribute.ts
 var attribute_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$9 });
-const OPEN_TAG_END_TOKENS = new Set([TokenTypes.OpenTagEnd]);
-function construct$9(token, state) {
-	if (OPEN_TAG_END_TOKENS.has(token.type)) return handleOpenTagEnd$1(state);
-	if (token.type === TokenTypes.AttributeKey) return handleAttributeKey(state, token);
-	if (token.type === TokenTypes.AttributeAssignment) return handleAttributeAssignment(state);
-	state.caretPosition++;
-	return state;
-}
-function handleOpenTagEnd$1(state) {
-	state.currentContext = state.currentContext.parentRef;
-	return state;
-}
-function handleAttributeKey(state, token) {
-	const attribute = getLastAttribute(state);
-	if (attribute.key !== void 0 || attribute.value !== void 0) {
-		state.currentContext = state.currentContext.parentRef;
-		return state;
-	}
-	attribute.key = createNodeFrom(token);
-	state.caretPosition++;
-	return state;
-}
-function handleAttributeAssignment(state) {
-	if (getLastAttribute(state).value !== void 0) {
-		state.currentContext = state.currentContext.parentRef;
-		return state;
+const dispatch$9 = createTokenDispatcher([
+	{
+		tokenType: new Set([TokenTypes.OpenTagEnd]),
+		handler(_, state) {
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeKey,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			if (attribute.key !== void 0 || attribute.value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			attribute.key = createNodeFrom(token);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeAssignment,
+		handler(_, state) {
+			if (getLastAttribute(state).value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.AttributeValue
+			};
+			state.caretPosition++;
+			return state;
+		}
 	}
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.AttributeValue
-	};
+], (_, state) => {
 	state.caretPosition++;
 	return state;
+});
+function construct$9(token, state) {
+	return dispatch$9(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/attributes.ts
 var attributes_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct$8 });
-const ATTRIBUTE_START_TOKENS$1 = new Set([TokenTypes.AttributeKey, TokenTypes.AttributeAssignment]);
+const ATTRIBUTE_START_TOKENS$2 = new Set([TokenTypes.AttributeKey, TokenTypes.AttributeAssignment]);
 const ATTRIBUTE_END_TOKENS = new Set([TokenTypes.OpenTagEnd]);
-function construct$8(token, state) {
-	if (ATTRIBUTE_START_TOKENS$1.has(token.type)) return handleAttributeStart(state, token);
-	if (ATTRIBUTE_END_TOKENS.has(token.type)) return handleOpenTagEnd(state);
+const dispatch$8 = createTokenDispatcher([{
+	tokenType: ATTRIBUTE_START_TOKENS$2,
+	handler(token, state) {
+		initAttributesIfNone(state.currentNode);
+		state.currentNode.attributes.push({
+			type: NodeTypes.Attribute,
+			range: cloneRange(token.range),
+			loc: cloneLocation(token.loc)
+		});
+		state.currentContext = {
+			parentRef: state.currentContext,
+			type: ConstructTreeContextTypes.Attribute
+		};
+		return state;
+	}
+}, {
+	tokenType: ATTRIBUTE_END_TOKENS,
+	handler(_, state) {
+		state.currentContext = state.currentContext.parentRef;
+		return state;
+	}
+}], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleAttributeStart(state, token) {
-	initAttributesIfNone(state.currentNode);
-	state.currentNode.attributes.push({
-		type: NodeTypes.Attribute,
-		range: cloneRange(token.range),
-		loc: cloneLocation(token.loc)
-	});
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.Attribute
-	};
-	return state;
-}
-function handleOpenTagEnd(state) {
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct$8(token, state) {
+	return dispatch$8(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/tagContent.ts
 var tagContent_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$7 });
-function construct$7(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) return handleOpenTagStart(state, token);
-	if (token.type === TokenTypes.Text) return handleText(state, token);
-	if (token.type === TokenTypes.CloseTag) return handleCloseTag(state, token);
-	if (token.type === TokenTypes.CommentOpen) return handleCommentOpen(state, token);
-	if (token.type === TokenTypes.DoctypeOpen) return handleDoctypeOpen(state, token);
-	state.caretPosition++;
-	return state;
-}
-function handleOpenTagStart(state, token) {
-	initChildrenIfNone(state.currentNode);
-	const tagNode = {
-		type: NodeTypes.Tag,
-		parentRef: state.currentNode,
-		range: cloneRange(token.range),
-		loc: cloneLocation(token.loc),
-		attributes: [],
-		children: []
-	};
-	state.currentNode.children.push(tagNode);
-	state.currentNode = tagNode;
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.Tag
-	};
-	return state;
-}
-function handleText(state, token) {
-	initChildrenIfNone(state.currentNode);
-	const textNode = createNodeFrom(token);
-	state.currentNode.children.push(textNode);
-	state.caretPosition++;
-	return state;
-}
-function handleCloseTag(state, token) {
-	if (parseCloseTagName(token.value) !== state.currentNode.name) {
-		state.caretPosition++;
-		return state;
+const dispatch$7 = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.OpenTagStart,
+		handler(token, state) {
+			initChildrenIfNone(state.currentNode);
+			const tagNode = {
+				type: NodeTypes.Tag,
+				parentRef: state.currentNode,
+				range: cloneRange(token.range),
+				loc: cloneLocation(token.loc),
+				attributes: [],
+				children: []
+			};
+			state.currentNode.children.push(tagNode);
+			state.currentNode = tagNode;
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.Tag
+			};
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.Text,
+		handler(token, state) {
+			initChildrenIfNone(state.currentNode);
+			const textNode = createNodeFrom(token);
+			state.currentNode.children.push(textNode);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.CloseTag,
+		handler(token, state) {
+			if (parseCloseTagName(token.value) !== state.currentNode.name) {
+				state.caretPosition++;
+				return state;
+			}
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.CommentOpen,
+		handler(token, state) {
+			initChildrenIfNone(state.currentNode);
+			const commentNode = {
+				type: NodeTypes.Comment,
+				parentRef: state.currentNode,
+				range: cloneRange(token.range),
+				loc: cloneLocation(token.loc)
+			};
+			state.currentNode.children.push(commentNode);
+			state.currentNode = commentNode;
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.Comment
+			};
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.DoctypeOpen,
+		handler(token, state) {
+			initChildrenIfNone(state.currentNode);
+			const doctypeNode = {
+				type: NodeTypes.Doctype,
+				parentRef: state.currentNode,
+				range: cloneRange(token.range),
+				loc: cloneLocation(token.loc),
+				attributes: []
+			};
+			state.currentNode.children.push(doctypeNode);
+			state.currentNode = doctypeNode;
+			state.currentContext = {
+				parentRef: state.currentContext,
+				type: ConstructTreeContextTypes.Doctype
+			};
+			return state;
+		}
 	}
-	state.currentContext = state.currentContext.parentRef;
-	return state;
-}
-function handleCommentOpen(state, token) {
-	initChildrenIfNone(state.currentNode);
-	const commentNode = {
-		type: NodeTypes.Comment,
-		parentRef: state.currentNode,
-		range: cloneRange(token.range),
-		loc: cloneLocation(token.loc)
-	};
-	state.currentNode.children.push(commentNode);
-	state.currentNode = commentNode;
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.Comment
-	};
-	return state;
-}
-function handleDoctypeOpen(state, token) {
-	initChildrenIfNone(state.currentNode);
-	const doctypeNode = {
-		type: NodeTypes.Doctype,
-		parentRef: state.currentNode,
-		range: cloneRange(token.range),
-		loc: cloneLocation(token.loc),
-		attributes: []
-	};
-	state.currentNode.children.push(doctypeNode);
-	state.currentNode = doctypeNode;
-	state.currentContext = {
-		parentRef: state.currentContext,
-		type: ConstructTreeContextTypes.Doctype
-	};
+], (_, state) => {
+	state.caretPosition++;
 	return state;
+});
+function construct$7(token, state) {
+	return dispatch$7(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/attributeValue.ts
 var attributeValue_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct$6 });
-const VALUE_END_TOKENS = new Set([
-	TokenTypes.OpenTagEnd,
-	TokenTypes.AttributeKey,
-	TokenTypes.AttributeAssignment
-]);
-function construct$6(token, state) {
-	if (VALUE_END_TOKENS.has(token.type)) return handleValueEnd(state);
-	if (token.type === TokenTypes.AttributeValue) return handleAttributeValue(state, token);
-	if (token.type === TokenTypes.AttributeValueWrapperStart) return handleAttributeValueWrapperStart(state, token);
-	if (token.type === TokenTypes.AttributeValueWrapperEnd) return handleAttributeValueWrapperEnd(state, token);
-	state.caretPosition++;
-	return state;
-}
-function handleValueEnd(state) {
-	state.currentContext = state.currentContext.parentRef;
-	return state;
-}
-function handleAttributeValue(state, token) {
-	const attribute = getLastAttribute(state);
-	attribute.value = createNodeFrom(token);
-	updateNodeEnd(attribute, token);
-	state.caretPosition++;
-	return state;
-}
-function handleAttributeValueWrapperStart(state, token) {
-	const attribute = getLastAttribute(state);
-	attribute.startWrapper = createNodeFrom(token);
-	if (!attribute.key) {
-		attribute.range = cloneRange(token.range);
-		attribute.loc = cloneLocation(token.loc);
+const dispatch$6 = createTokenDispatcher([
+	{
+		tokenType: new Set([
+			TokenTypes.OpenTagEnd,
+			TokenTypes.AttributeKey,
+			TokenTypes.AttributeAssignment
+		]),
+		handler(_, state) {
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValue,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			attribute.value = createNodeFrom(token);
+			updateNodeEnd(attribute, token);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperStart,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			attribute.quoteChar = token.value;
+			if (!attribute.key) {
+				attribute.range = cloneRange(token.range);
+				attribute.loc = cloneLocation(token.loc);
+			}
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperEnd,
+		handler(token, state) {
+			updateNodeEnd(getLastAttribute(state), token);
+			state.caretPosition++;
+			return state;
+		}
 	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleAttributeValueWrapperEnd(state, token) {
-	const attribute = getLastAttribute(state);
-	attribute.endWrapper = createNodeFrom(token);
-	updateNodeEnd(attribute, token);
-	state.caretPosition++;
-	return state;
+});
+function construct$6(token, state) {
+	return dispatch$6(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/xmlDeclaration.ts
 var xmlDeclaration_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$5 });
-function construct$5(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) handleTagOpenStart$3(state, token);
+const dispatch$5 = createTokenDispatcher([{
+	tokenType: TokenTypes.OpenTagStart,
+	handler(token, state) {
+		state.currentNode.name = parseOpenTagName(token.value);
+		state.currentContext = state.currentContext.parentRef;
+		state.caretPosition++;
+		return state;
+	}
+}], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleTagOpenStart$3(state, token) {
-	state.currentNode.name = parseOpenTagName(token.value);
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct$5(token, state) {
+	return dispatch$5(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/doctypeAttribute.ts
 var doctypeAttribute_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$4 });
-function construct$4(token, state) {
-	if (token.type === TokenTypes.DoctypeClose) return handleDoctypeClose$1(state);
-	if (token.type === TokenTypes.DoctypeAttributeWrapperStart) return handleDoctypeAttributeWrapperStart(state, token);
-	if (token.type === TokenTypes.DoctypeAttributeWrapperEnd) return handleDoctypeAttributeWrapperEnd(state, token);
-	if (token.type === TokenTypes.DoctypeAttributeValue) return handleDoctypeAttributeValue(state, token);
+const dispatch$4 = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.DoctypeClose,
+		handler(_, state) {
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.DoctypeAttributeWrapperStart,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			if (attribute.value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			attribute.quoteChar = token.value;
+			attribute.range = cloneRange(token.range);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.DoctypeAttributeWrapperEnd,
+		handler(token, state) {
+			updateNodeEnd(getLastAttribute(state), token);
+			state.currentContext = state.currentContext.parentRef;
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.DoctypeAttributeValue,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			if (attribute.value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			attribute.value = createNodeFrom(token);
+			if (!attribute.quoteChar) attribute.range = cloneRange(token.range);
+			state.caretPosition++;
+			return state;
+		}
+	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
+});
+function construct$4(token, state) {
+	return dispatch$4(token, state);
 }
-function handleDoctypeClose$1(state) {
-	state.currentContext = state.currentContext.parentRef;
-	return state;
-}
-function handleDoctypeAttributeWrapperStart(state, token) {
-	const attribute = getLastAttribute(state);
-	if (attribute.value !== void 0) {
+
+//#endregion
+//#region src/constructor/handlers/doctypeAttributes.ts
+var doctypeAttributes_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct$3 });
+const ATTRIBUTE_START_TOKENS$1 = new Set([TokenTypes.DoctypeAttributeWrapperStart, TokenTypes.DoctypeAttributeValue]);
+const dispatch$3 = createTokenDispatcher([{
+	tokenType: TokenTypes.DoctypeClose,
+	handler(_, state) {
 		state.currentContext = state.currentContext.parentRef;
 		return state;
 	}
-	attribute.startWrapper = createNodeFrom(token);
-	attribute.range = cloneRange(token.range);
-	state.caretPosition++;
-	return state;
-}
-function handleDoctypeAttributeWrapperEnd(state, token) {
-	const attribute = getLastAttribute(state);
-	attribute.endWrapper = createNodeFrom(token);
-	updateNodeEnd(attribute, token);
-	state.currentContext = state.currentContext.parentRef;
-	state.caretPosition++;
-	return state;
-}
-function handleDoctypeAttributeValue(state, token) {
-	const attribute = getLastAttribute(state);
-	if (attribute.value !== void 0) {
-		state.currentContext = state.currentContext.parentRef;
+}, {
+	tokenType: ATTRIBUTE_START_TOKENS$1,
+	handler(token, state) {
+		initAttributesIfNone(state.currentNode);
+		state.currentNode.attributes.push({
+			type: NodeTypes.DoctypeAttribute,
+			range: cloneRange(token.range),
+			loc: cloneLocation(token.loc)
+		});
+		state.currentContext = {
+			type: ConstructTreeContextTypes.DoctypeAttribute,
+			parentRef: state.currentContext
+		};
 		return state;
 	}
-	attribute.value = createNodeFrom(token);
-	if (!attribute.startWrapper) attribute.range = cloneRange(token.range);
+}], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-
-//#endregion
-//#region src/constructor/handlers/doctypeAttributes.ts
-var doctypeAttributes_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct$3 });
-const ATTRIBUTE_START_TOKENS = new Set([TokenTypes.DoctypeAttributeWrapperStart, TokenTypes.DoctypeAttributeValue]);
+});
 function construct$3(token, state) {
-	if (token.type === TokenTypes.DoctypeClose) return handleDoctypeClose(state);
-	if (ATTRIBUTE_START_TOKENS.has(token.type)) return handleAttribute(state, token);
-	state.caretPosition++;
-	return state;
-}
-function handleDoctypeClose(state) {
-	state.currentContext = state.currentContext.parentRef;
-	return state;
-}
-function handleAttribute(state, token) {
-	initAttributesIfNone(state.currentNode);
-	state.currentNode.attributes.push({
-		type: NodeTypes.DoctypeAttribute,
-		range: cloneRange(token.range),
-		loc: cloneLocation(token.loc)
-	});
-	state.currentContext = {
-		type: ConstructTreeContextTypes.DoctypeAttribute,
-		parentRef: state.currentContext
-	};
-	return state;
+	return dispatch$3(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/xmlDeclarationAttribute.ts
 var xmlDeclarationAttribute_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$2 });
-function construct$2(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) handleTagOpenStart$2(state, token);
+const dispatch$2 = createTokenDispatcher([
+	{
+		tokenType: new Set([
+			TokenTypes.OpenTagEnd,
+			TokenTypes.AttributeKey,
+			TokenTypes.AttributeAssignment
+		]),
+		handler(_, state) {
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValue,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			attribute.value = createNodeFrom(token);
+			updateNodeEnd(attribute, token);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperStart,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			attribute.quoteChar = token.value;
+			if (!attribute.key) attribute.range = cloneRange(token.range);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperEnd,
+		handler(token, state) {
+			updateNodeEnd(getLastAttribute(state), token);
+			state.caretPosition++;
+			return state;
+		}
+	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleTagOpenStart$2(state, token) {
-	state.currentNode.name = parseOpenTagName(token.value);
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct$2(token, state) {
+	return dispatch$2(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/xmlDeclarationAttributes.ts
 var xmlDeclarationAttributes_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct$1 });
-function construct$1(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) handleTagOpenStart$1(state, token);
+const ATTRIBUTE_START_TOKENS = new Set([TokenTypes.AttributeKey, TokenTypes.AttributeAssignment]);
+const dispatch$1 = createTokenDispatcher([{
+	tokenType: TokenTypes.OpenTagEnd,
+	handler(_, state) {
+		state.currentContext = state.currentContext.parentRef;
+		return state;
+	}
+}, {
+	tokenType: ATTRIBUTE_START_TOKENS,
+	handler(token, state) {
+		initAttributesIfNone(state.currentNode);
+		state.currentNode.attributes.push({
+			type: NodeTypes.Attribute,
+			range: cloneRange(token.range),
+			loc: cloneLocation(token.loc)
+		});
+		state.currentContext = {
+			type: ConstructTreeContextTypes.XMLDeclarationAttribute,
+			parentRef: state.currentContext
+		};
+		return state;
+	}
+}], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleTagOpenStart$1(state, token) {
-	state.currentNode.name = parseOpenTagName(token.value);
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct$1(token, state) {
+	return dispatch$1(token, state);
 }
 
 //#endregion
 //#region src/constructor/handlers/xmlDeclarationAttributeValue.ts
 var xmlDeclarationAttributeValue_exports$1 = /* @__PURE__ */ __exportAll({ construct: () => construct });
-function construct(token, state) {
-	if (token.type === TokenTypes.OpenTagStart) handleTagOpenStart(state, token);
+const dispatch = createTokenDispatcher([
+	{
+		tokenType: TokenTypes.OpenTagEnd,
+		handler(_, state) {
+			state.currentContext = state.currentContext.parentRef;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValue,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			if (attribute.value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			attribute.value = createNodeFrom(token);
+			if (!attribute.quoteChar) attribute.range = cloneRange(token.range);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperStart,
+		handler(token, state) {
+			const attribute = getLastAttribute(state);
+			if (attribute.value !== void 0) {
+				state.currentContext = state.currentContext.parentRef;
+				return state;
+			}
+			attribute.quoteChar = token.value;
+			attribute.range = cloneRange(token.range);
+			state.caretPosition++;
+			return state;
+		}
+	},
+	{
+		tokenType: TokenTypes.AttributeValueWrapperEnd,
+		handler(token, state) {
+			updateNodeEnd(getLastAttribute(state), token);
+			state.currentContext = state.currentContext.parentRef;
+			state.caretPosition++;
+			return state;
+		}
+	}
+], (_, state) => {
 	state.caretPosition++;
 	return state;
-}
-function handleTagOpenStart(state, token) {
-	state.currentNode.name = parseOpenTagName(token.value);
-	state.currentContext = state.currentContext.parentRef;
-	return state;
+});
+function construct(token, state) {
+	return dispatch(token, state);
 }
 
 //#endregion
@@ -1883,43 +2419,20 @@ function parse$1(source, _options = {}) {
 const keys = {
 	Program: ["body"],
 	Document: ["children"],
-	XMLDeclaration: [],
-	XMLDeclarationOpen: [],
-	XMLDeclarationClose: [],
+	XMLDeclaration: ["attributes"],
 	XMLDeclarationAttribute: ["key", "value"],
 	XMLDeclarationAttributeKey: [],
 	XMLDeclarationAttributeValue: [],
-	XMLDeclarationAttributeValueWrapperStart: [],
-	XMLDeclarationAttributeValueWrapperEnd: [],
-	Doctype: [
-		"open",
-		"close",
-		"attributes"
-	],
-	DoctypeOpen: [],
-	DoctypeClose: [],
-	DoctypeAttribute: ["key", "value"],
-	DoctypeAttributeValue: ["value"],
-	DoctypeAttributeWrapperEnd: [],
-	DoctypeAttributeWrapperStart: [],
+	Doctype: ["attributes"],
+	DoctypeAttribute: ["value"],
+	DoctypeAttributeValue: [],
 	Attribute: ["key", "value"],
-	AttributeKey: ["value"],
-	AttributeValue: ["value"],
-	AttributeValueWrapperEnd: [],
-	AttributeValueWrapperStart: [],
-	Tag: ["children", "attributes"],
-	OpenTagEnd: [],
-	OpenTagStart: [],
-	CloseTag: [],
-	Comment: [
-		"open",
-		"close",
-		"value"
-	],
-	CommentOpen: [],
-	CommentClose: [],
-	CommentContent: [],
-	Text: []
+	AttributeKey: [],
+	AttributeValue: [],
+	Tag: ["attributes", "children"],
+	Comment: [],
+	Text: [],
+	Error: []
 };
 let vistorKeysCache = null;
 function getVisitorKeys() {
@@ -1946,21 +2459,17 @@ function traverse(node, visitor) {
 //#region src/parser/parseForESLint.ts
 function parseForESLint(source, options = {}) {
 	const { ast, tokens } = parse$1(source, options);
+	const comments = [];
 	const programNode = {
 		type: NodeTypes.Program,
 		body: [ast],
-		comments: [],
+		comments,
 		tokens: tokens.filter((token) => token.type !== TokenTypes.CommentOpen && token.type !== TokenTypes.CommentClose && token.type !== TokenTypes.CommentContent),
 		range: ast.range,
 		loc: ast.loc
 	};
 	traverse(programNode, (node) => {
-		if (node.type === NodeTypes.CommentContent) programNode.comments.push({
-			type: node.type,
-			range: node.range,
-			loc: node.loc,
-			value: node.value
-		});
+		if (node.type === NodeTypes.Comment && "content" in node) comments.push(node.content);
 	});
 	return {
 		ast: programNode,
@@ -1979,4 +2488,4 @@ function parse(code, options = {}) {
 }
 
 //#endregion
-export { COMMENT_END, COMMENT_START, ConstructTreeContextTypes, DEPRECATED_SVG_ELEMENTS, NodeTypes, ParseError, RE_CLOSE_TAG_NAME, RE_INCOMPLETE_CLOSING_TAG, RE_OPEN_TAG_NAME, RE_OPEN_TAG_START, SELF_CLOSING_ELEMENTS, SPECIAL_CHAR, SVG_ELEMENTS, TokenTypes, TokenizerContextTypes, VisitorKeys, XML_DECLARATION_END, XML_DECLARATION_START, meta, name, parse, parseForESLint };
+export { COMMENT_END, COMMENT_START, ConstructTreeContextTypes, DEPRECATED_SVG_ELEMENTS, NodeTypes, ParseError, RE_CLOSE_TAG_NAME, RE_INCOMPLETE_CLOSING_TAG, RE_OPEN_TAG_NAME, RE_OPEN_TAG_START, SELF_CLOSING_ELEMENTS, SPECIAL_CHAR, SVG_ELEMENTS, TokenTypes, TokenizerContextTypes, VisitorKeys, XML_DECLARATION_END, XML_DECLARATION_START, cloneNode, cloneNodeWithParent, countNodes, filterNodes, findFirstNodeByType, findNodeByType, getNodeDepth, getParentChain, isNodeType, mapNodes, meta, name, parse, parseForESLint, traverseAST, validateNode, walkAST };