svg-eslint-parser 0.0.4 → 0.0.5

package/dist/index.js

@@ -0,0 +1,1982 @@
+import { t as __exportAll } from "./chunk-CzXV76rE.js";
+import { unionWith } from "eslint-visitor-keys";
+
+//#region package.json
+var name$1 = "svg-eslint-parser";
+var version = "0.0.5";
+
+//#endregion
+//#region src/meta.ts
+const meta = {
+	name: name$1,
+	version
+};
+
+//#endregion
+//#region src/parser/error.ts
+/**
+* parse error
+*/
+var ParseError = class extends SyntaxError {
+	index;
+	lineNumber;
+	column;
+	constructor(message, offset, line, column) {
+		super(message);
+		this.name = "ParseError";
+		this.index = offset;
+		this.lineNumber = line;
+		this.column = column;
+	}
+};
+
+//#endregion
+//#region src/constants/parse.ts
+/**
+* svg comment start
+*/
+const COMMENT_START = "<!--";
+/**
+* svg comment end
+*/
+const COMMENT_END = "-->";
+/**
+* xml declaration start
+*/
+const XML_DECLARATION_START = "<?xml";
+/**
+* xml declaration end
+*/
+const XML_DECLARATION_END = "?>";
+/**
+* regexp for open tag start
+* @regex101 https://regex101.com/?regex=%5E%3C%5Cw&flavor=javascript
+*/
+const RE_OPEN_TAG_START = /^<\w/;
+/**
+* regexp for open tag name
+* @regex101 https://regex101.com/?regex=%5E%3C%28%5CS%2B%29&flavor=javascript
+*/
+const RE_OPEN_TAG_NAME = /^<(\S+)/;
+/**
+* regexp for close tag name
+* @regex101 https://regex101.com/?regex=%5E%3C%5C%2F%28%28%3F%3A.%7C%5Cr%3F%5Cn%29*%29%3E%24&flavor=javascript
+*/
+const RE_CLOSE_TAG_NAME = /^<\/((?:.|\r?\n)*)>$/;
+/**
+* regexp for incomplete closing tag
+* @regex101 https://regex101.com/?regex=%3C%5C%2F%5B%5E%3E%5D%2B%24&flavor=javascript
+*/
+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;
+}({});
+
+//#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;
+}({});
+
+//#endregion
+//#region src/constants/specialChar.ts
+const SPECIAL_CHAR = {
+	closingCorner: `>`,
+	colon: `:`,
+	comma: `,`,
+	doubleQuote: `"`,
+	equal: `=`,
+	exclamation: `!`,
+	hyphen: `-`,
+	newline: `\n`,
+	openingCorner: `<`,
+	question: `?`,
+	return: `\r`,
+	singleQuote: `'`,
+	slash: `/`,
+	space: ` `,
+	tab: `\t`
+};
+
+//#endregion
+//#region src/constants/svgElements.ts
+/**
+* @copyright {@link https://github.com/davidohlin/svg-elements}
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element}
+*/
+const SVG_ELEMENTS = new Set([
+	"a",
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"color-profile",
+	"defs",
+	"desc",
+	"ellipse",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"filter",
+	"foreignObject",
+	"g",
+	"image",
+	"line",
+	"linearGradient",
+	"marker",
+	"mask",
+	"metadata",
+	"mpath",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialGradient",
+	"rect",
+	"script",
+	"set",
+	"stop",
+	"style",
+	"svg",
+	"switch",
+	"symbol",
+	"text",
+	"textPath",
+	"title",
+	"tspan",
+	"use",
+	"view"
+]);
+/**
+* obsolete and deprecated elements
+*
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element#obsolete_and_deprecated_elements}
+*/
+const DEPRECATED_SVG_ELEMENTS = new Set([
+	"altGlyph",
+	"altGlyphDef",
+	"altGlyphItem",
+	"animateColor",
+	"cursor",
+	"font",
+	"font-face",
+	"font-face-format",
+	"font-face-name",
+	"font-face-src",
+	"font-face-uri",
+	"glyph",
+	"glyphRef",
+	"hkern",
+	"missing-glyph",
+	"tref",
+	"vkern"
+]);
+/**
+* self closing svg elements
+*/
+const SELF_CLOSING_ELEMENTS = new Set([
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"ellipse",
+	"feBlend",
+	"feColorMatrix",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDisplacementMap",
+	"feDropShadow",
+	"feFlood",
+	"feGaussianBlur",
+	"feImage",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"image",
+	"line",
+	"mpath",
+	"path",
+	"polygon",
+	"polyline",
+	"rect",
+	"set",
+	"stop",
+	"use",
+	"view"
+]);
+
+//#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;
+}({});
+
+//#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;
+}({});
+
+//#endregion
+//#region src/utils/firstLast.ts
+function first(items) {
+	return items[0];
+}
+function last(items) {
+	return items[items.length - 1];
+}
+
+//#endregion
+//#region src/utils/cloneRange.ts
+function cloneRange(range) {
+	return [range[0], range[1]];
+}
+
+//#endregion
+//#region src/utils/initIfNone.ts
+function initChildrenIfNone(node) {
+	if (!node.children) node.children = [];
+}
+function initAttributesIfNone(node) {
+	if (!node.attributes) node.attributes = [];
+}
+
+//#endregion
+//#region src/utils/clearParent.ts
+function clearParent(ast) {
+	const cleanAst = ast;
+	delete cleanAst.parentRef;
+	if (Array.isArray(ast.children)) cleanAst.children = ast.children.map((node) => {
+		return clearParent(node);
+	});
+	return cleanAst;
+}
+
+//#endregion
+//#region src/utils/getLineInfo.ts
+function isNewLine(code) {
+	return code === 10 || code === 13 || code === 8232 || code === 8233;
+}
+function nextLineBreak(code, from, end = code.length) {
+	for (let i = from; i < end; i++) {
+		const next = code.codePointAt(i);
+		if (!next) continue;
+		if (isNewLine(next)) return i < end - 1 && next === 13 && code.codePointAt(i + 1) === 10 ? i + 2 : i + 1;
+	}
+	return -1;
+}
+function getLineInfo(input, offset) {
+	for (let line = 1, cur = 0;;) {
+		const nextBreak = nextLineBreak(input, cur, offset);
+		if (nextBreak < 0) return {
+			line,
+			column: offset - cur
+		};
+		++line;
+		cur = nextBreak;
+	}
+}
+
+//#endregion
+//#region src/utils/isWhitespace.ts
+function isWhitespace(char) {
+	return char === SPECIAL_CHAR.space || char === SPECIAL_CHAR.newline || char === SPECIAL_CHAR.return || char === SPECIAL_CHAR.tab;
+}
+
+//#endregion
+//#region src/utils/cloneLocation.ts
+function cloneLocation(loc) {
+	return {
+		start: {
+			line: loc.start.line,
+			column: loc.start.column
+		},
+		end: {
+			line: loc.end.line,
+			column: loc.end.column
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/updateNodeEnd.ts
+function updateNodeEnd(node, token) {
+	node.range[1] = token.range[1];
+	node.loc.end = { ...token.loc.end };
+}
+
+//#endregion
+//#region src/utils/createNodeFrom.ts
+function createNodeFrom(token) {
+	const loc = cloneLocation(token.loc);
+	const range = cloneRange(token.range);
+	return {
+		type: token.type,
+		value: token.value,
+		loc,
+		range
+	};
+}
+
+//#endregion
+//#region src/utils/getLastAttribute.ts
+function getLastAttribute(state) {
+	const attributes = state.currentNode.attributes;
+	return last(attributes);
+}
+
+//#endregion
+//#region src/utils/parseOpenTagName.ts
+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.`);
+	return match[1].toLowerCase();
+}
+
+//#endregion
+//#region src/utils/parseCloseTagName.ts
+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.`);
+	return match[1].trim().toLowerCase();
+}
+
+//#endregion
+//#region src/utils/calculateTokenLocation.ts
+function calculateTokenLocation(source, range) {
+	return {
+		start: getLineInfo(source, range[0]),
+		end: getLineInfo(source, range[1])
+	};
+}
+
+//#endregion
+//#region src/utils/calculateTokenCharactersRange.ts
+function calculateTokenCharactersRange(state, options) {
+	const startPosition = state.sourceCode.index() - (state.accumulatedContent.length() - 1) - state.decisionBuffer.length();
+	let endPosition;
+	if (options.keepBuffer) endPosition = state.sourceCode.index();
+	else endPosition = state.sourceCode.index() - state.decisionBuffer.length();
+	return [startPosition, endPosition + 1];
+}
+
+//#endregion
+//#region src/utils/calculateTokenPosition.ts
+function calculateTokenPosition(state, options) {
+	const range = calculateTokenCharactersRange(state, options);
+	return {
+		range,
+		loc: calculateTokenLocation(state.sourceCode.source, range)
+	};
+}
+
+//#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++;
+		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;
+	state.caretPosition++;
+	return state;
+}
+
+//#endregion
+//#region src/constructor/handlers/comment.ts
+var comment_exports = /* @__PURE__ */ __exportAll({ construct: () => construct$12 });
+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;
+}
+
+//#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;
+	state.caretPosition++;
+	return state;
+}
+function handleDoctypeAttributes(state) {
+	state.currentContext = {
+		parentRef: state.currentContext,
+		type: ConstructTreeContextTypes.DoctypeAttributes
+	};
+	return 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);
+	state.caretPosition++;
+	return state;
+}
+function handleTagOpenStart$4(state, token) {
+	state.currentNode.name = parseOpenTagName(token.value);
+	state.currentContext = state.currentContext.parentRef;
+	return 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;
+	}
+	state.currentContext = {
+		parentRef: state.currentContext,
+		type: ConstructTreeContextTypes.AttributeValue
+	};
+	state.caretPosition++;
+	return 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_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);
+	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;
+}
+
+//#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;
+	}
+	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
+	};
+	return 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);
+	}
+	state.caretPosition++;
+	return state;
+}
+function handleAttributeValueWrapperEnd(state, token) {
+	const attribute = getLastAttribute(state);
+	attribute.endWrapper = createNodeFrom(token);
+	updateNodeEnd(attribute, token);
+	state.caretPosition++;
+	return 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);
+	state.caretPosition++;
+	return state;
+}
+function handleTagOpenStart$3(state, token) {
+	state.currentNode.name = parseOpenTagName(token.value);
+	state.currentContext = state.currentContext.parentRef;
+	return 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);
+	state.caretPosition++;
+	return 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) {
+		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;
+		return state;
+	}
+	attribute.value = createNodeFrom(token);
+	if (!attribute.startWrapper) attribute.range = cloneRange(token.range);
+	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;
+}
+
+//#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);
+	state.caretPosition++;
+	return state;
+}
+function handleTagOpenStart$2(state, token) {
+	state.currentNode.name = parseOpenTagName(token.value);
+	state.currentContext = state.currentContext.parentRef;
+	return 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);
+	state.caretPosition++;
+	return state;
+}
+function handleTagOpenStart$1(state, token) {
+	state.currentNode.name = parseOpenTagName(token.value);
+	state.currentContext = state.currentContext.parentRef;
+	return 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);
+	state.caretPosition++;
+	return state;
+}
+function handleTagOpenStart(state, token) {
+	state.currentNode.name = parseOpenTagName(token.value);
+	state.currentContext = state.currentContext.parentRef;
+	return state;
+}
+
+//#endregion
+//#region src/constructor/constructTree.ts
+const EMPTY_RANGE = [0, 0];
+const EMPTY_LOC = {
+	start: {
+		line: 1,
+		column: 0
+	},
+	end: {
+		line: 1,
+		column: 0
+	}
+};
+const contextHandlers$1 = {
+	[ConstructTreeContextTypes.Tag]: tag_exports,
+	[ConstructTreeContextTypes.TagName]: tagName_exports,
+	[ConstructTreeContextTypes.TagContent]: tagContent_exports,
+	[ConstructTreeContextTypes.Attributes]: attributes_exports$1,
+	[ConstructTreeContextTypes.Attribute]: attribute_exports,
+	[ConstructTreeContextTypes.AttributeValue]: attributeValue_exports$1,
+	[ConstructTreeContextTypes.Doctype]: doctype_exports,
+	[ConstructTreeContextTypes.DoctypeAttribute]: doctypeAttribute_exports,
+	[ConstructTreeContextTypes.DoctypeAttributes]: doctypeAttributes_exports$1,
+	[ConstructTreeContextTypes.Comment]: comment_exports,
+	[ConstructTreeContextTypes.XMLDeclaration]: xmlDeclaration_exports,
+	[ConstructTreeContextTypes.XMLDeclarationAttribute]: xmlDeclarationAttribute_exports,
+	[ConstructTreeContextTypes.XMLDeclarationAttributes]: xmlDeclarationAttributes_exports$1,
+	[ConstructTreeContextTypes.XMLDeclarationAttributeValue]: xmlDeclarationAttributeValue_exports$1
+};
+function constructTree(tokens) {
+	const rootContext = {
+		type: ConstructTreeContextTypes.TagContent,
+		parentRef: void 0,
+		content: []
+	};
+	const lastToken = last(tokens);
+	const firstToken = first(tokens);
+	const range = lastToken ? [0, lastToken.range[1]] : EMPTY_RANGE;
+	const loc = lastToken && firstToken ? {
+		start: cloneLocation(firstToken.loc).start,
+		end: cloneLocation(lastToken.loc).end
+	} : EMPTY_LOC;
+	loc.start.line = 1;
+	const rootNode = {
+		type: NodeTypes.Document,
+		range,
+		children: [],
+		loc
+	};
+	const state = {
+		caretPosition: 0,
+		currentContext: rootContext,
+		currentNode: rootNode,
+		rootNode
+	};
+	const positionOffset = state.caretPosition;
+	processTokens(tokens, state, positionOffset);
+	return {
+		state,
+		ast: state.rootNode
+	};
+}
+function processTokens(tokens, state, positionOffset) {
+	let tokenIndex = state.caretPosition - positionOffset;
+	while (tokenIndex < tokens.length) {
+		const token = tokens[tokenIndex];
+		const handler = contextHandlers$1[state.currentContext.type].construct;
+		state = handler(token, state);
+		tokenIndex = state.caretPosition - positionOffset;
+	}
+	return state;
+}
+
+//#endregion
+//#region src/tokenizer/charsBuffer.ts
+var CharsBuffer = class {
+	charsBuffer = [];
+	concat(chars) {
+		const last$1 = this.last();
+		if (last$1) last$1.concat(chars);
+		else this.charsBuffer.push(chars);
+	}
+	concatBuffer(buffer) {
+		this.charsBuffer.push(...buffer.charsBuffer);
+	}
+	length() {
+		return this.charsBuffer.map((chars) => chars.length()).reduce((a, b) => a + b, 0);
+	}
+	clear() {
+		this.charsBuffer = [];
+	}
+	value() {
+		return this.charsBuffer.map((chars) => chars.value).join("");
+	}
+	last() {
+		return last(this.charsBuffer);
+	}
+	first() {
+		return first(this.charsBuffer);
+	}
+	removeLast() {
+		this.charsBuffer.splice(-1, 1);
+	}
+	removeFirst() {
+		this.charsBuffer.splice(0, 1);
+	}
+	replace(other) {
+		this.charsBuffer = [...other.charsBuffer];
+	}
+};
+
+//#endregion
+//#region src/tokenizer/handlers/data.ts
+var data_exports = /* @__PURE__ */ __exportAll({
+	handleContentEnd: () => handleContentEnd,
+	parse: () => parse$22
+});
+const INCOMPLETE_DOCTYPE_CHARS = new Set([
+	"<!",
+	"<!D",
+	"<!DO",
+	"<!DOC",
+	"<!DOCT",
+	"<!DOCTY",
+	"<!DOCTYP"
+]);
+function parse$22(chars, state) {
+	const value = chars.value();
+	if (value === XML_DECLARATION_START) return parseXMLDeclarationOpen(state);
+	if (RE_OPEN_TAG_START.test(value)) return parseOpeningCornerBraceWithText(state);
+	if (value === "</") return parseOpeningCornerBraceWithSlash(state);
+	if (value === SPECIAL_CHAR.openingCorner || value === "<!" || value === "<!-") return state.sourceCode.next();
+	if (value === COMMENT_START) return parseCommentOpen(state);
+	if (isIncompleteDoctype(value)) return state.sourceCode.next();
+	if (value.toUpperCase() === "<!DOCTYPE") return parseDoctypeOpen(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function handleContentEnd(state) {
+	const textContent = state.accumulatedContent.value() + state.decisionBuffer.value();
+	if (textContent.length !== 0) {
+		const position = calculateTokenPosition(state, { keepBuffer: false });
+		state.tokens.push({
+			type: TokenTypes.Text,
+			value: textContent,
+			range: position.range,
+			loc: position.loc
+		});
+	}
+}
+function generateTextToken(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	return {
+		type: TokenTypes.Text,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	};
+}
+function isIncompleteDoctype(chars) {
+	return INCOMPLETE_DOCTYPE_CHARS.has(chars.toUpperCase());
+}
+function parseOpeningCornerBraceWithText(state) {
+	if (state.accumulatedContent.length() !== 0) state.tokens.push(generateTextToken(state));
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.OpenTagStart;
+	state.sourceCode.next();
+}
+function parseOpeningCornerBraceWithSlash(state) {
+	if (state.accumulatedContent.length() !== 0) state.tokens.push(generateTextToken(state));
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.CloseTag;
+	state.sourceCode.next();
+}
+function parseCommentOpen(state) {
+	if (state.accumulatedContent.length() !== 0) state.tokens.push(generateTextToken(state));
+	const range = [state.sourceCode.index() - (COMMENT_START.length - 1), state.sourceCode.index() + 1];
+	state.tokens.push({
+		type: TokenTypes.CommentOpen,
+		value: state.decisionBuffer.value(),
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.CommentContent;
+	state.sourceCode.next();
+}
+function parseDoctypeOpen(state) {
+	if (state.accumulatedContent.length() !== 0) state.tokens.push(generateTextToken(state));
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeOpen;
+	state.sourceCode.next();
+}
+function parseXMLDeclarationOpen(state) {
+	if (state.accumulatedContent.length() !== 0) state.tokens.push(generateTextToken(state));
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.XMLDeclarationAttributes;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/closeTag.ts
+var closeTag_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$21 });
+function parse$21(chars, state) {
+	if (chars.value() === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace$5(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseClosingCornerBrace$5(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.CloseTag,
+		value: state.accumulatedContent.value() + state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/attributes.ts
+var attributes_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$20 });
+function parse$20(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) return parseTagEnd$3(state);
+	if (value === SPECIAL_CHAR.equal) return parseEqual(state);
+	if (!isWhitespace(value)) return parseNoneWhitespace(chars, state);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseTagEnd$3(state) {
+	const tagName = state.contextParams[TokenizerContextTypes.Attributes]?.tagName;
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.OpenTagEnd;
+	state.contextParams[TokenizerContextTypes.OpenTagEnd] = { tagName };
+	state.contextParams[TokenizerContextTypes.Attributes] = void 0;
+}
+function parseEqual(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.AttributeAssignment,
+		value: state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.AttributeValue;
+	state.sourceCode.next();
+}
+function parseNoneWhitespace(chars, state) {
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.currentContext = TokenizerContextTypes.AttributeKey;
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/openTagEnd.ts
+var openTagEnd_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$19 });
+function parse$19(chars, state) {
+	if (chars.value() === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace$4(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseClosingCornerBrace$4(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.OpenTagEnd,
+		value: state.accumulatedContent.value() + state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/doctypeOpen.ts
+var doctypeOpen_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$18 });
+function parse$18(chars, state) {
+	const value = chars.value();
+	if (isWhitespace(value)) return parseWhitespace$1(state);
+	if (value === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace$3(state);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function generateDoctypeOpenToken(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	return {
+		type: TokenTypes.DoctypeOpen,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	};
+}
+function parseWhitespace$1(state) {
+	state.tokens.push(generateDoctypeOpenToken(state));
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeAttributes;
+}
+function parseClosingCornerBrace$3(state) {
+	state.tokens.push(generateDoctypeOpenToken(state));
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeClose;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/attributeKey.ts
+var attributeKey_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$17 });
+function parse$17(chars, state) {
+	if (isKeyBreak$1(chars)) return parseKeyEnd$1(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function isKeyBreak$1(chars) {
+	const value = chars.value();
+	return value === SPECIAL_CHAR.equal || value === SPECIAL_CHAR.slash || value === SPECIAL_CHAR.closingCorner || isWhitespace(value);
+}
+function parseKeyEnd$1(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.AttributeKey,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/doctypeClose.ts
+var doctypeClose_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$16 });
+function parse$16(chars, state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.DoctypeClose,
+		value: state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/openTagStart.ts
+var openTagStart_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$15 });
+function parse$15(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) return parseTagEnd$2(state);
+	if (isWhitespace(value)) return parseWhitespace(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseTagEnd$2(state) {
+	const tagName = parseOpenTagName(state.accumulatedContent.value());
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.OpenTagStart,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.OpenTagEnd;
+	state.contextParams[TokenizerContextTypes.OpenTagEnd] = { tagName };
+}
+function parseWhitespace(state) {
+	const tagName = parseOpenTagName(state.accumulatedContent.value());
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.OpenTagStart,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+	state.contextParams[TokenizerContextTypes.Attributes] = { tagName };
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/attributeValue.ts
+var attributeValue_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$14 });
+function parse$14(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) return parseWrapper$5(state);
+	if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) return parseTagEnd$1(state);
+	if (!isWhitespace(value)) return parseBare$2(state);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper$5(state) {
+	const wrapper = state.decisionBuffer.value();
+	const range = [state.sourceCode.index(), state.sourceCode.index() + 1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValueWrapperStart,
+		value: wrapper,
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.AttributeValueWrapped;
+	state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = { wrapper };
+	state.sourceCode.next();
+}
+function parseTagEnd$1(state) {
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+}
+function parseBare$2(state) {
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.AttributeValueBare;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/commentContent.ts
+var commentContent_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$13 });
+function parse$13(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.hyphen || value === "--") return state.sourceCode.next();
+	if (value === COMMENT_END) return parseCommentClose(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseCommentClose(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	const endRange = [position.range[1], position.range[1] + COMMENT_END.length];
+	state.tokens.push({
+		type: TokenTypes.CommentContent,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.tokens.push({
+		type: TokenTypes.CommentClose,
+		value: state.decisionBuffer.value(),
+		range: endRange,
+		loc: state.sourceCode.getLocationOf(endRange)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/doctypeAttributes.ts
+var doctypeAttributes_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$12 });
+function parse$12(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) return parseWrapper$4(state);
+	if (value === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace$2(state);
+	if (!isWhitespace(value)) return parseBare$1(state);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper$4(state) {
+	const wrapper = state.decisionBuffer.value();
+	const range = [state.sourceCode.index(), state.sourceCode.index() + wrapper.length];
+	state.tokens.push({
+		type: TokenTypes.DoctypeAttributeWrapperStart,
+		value: wrapper,
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeAttributeWrapped;
+	state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped] = { wrapper };
+	state.sourceCode.next();
+}
+function parseClosingCornerBrace$2(state) {
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeClose;
+}
+function parseBare$1(state) {
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeAttributeBare;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/attributeValueBare.ts
+var attributeValueBare_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$11 });
+function parse$11(chars, state) {
+	const value = chars.value();
+	if (isWhitespace(value) || value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) return parseValueEnd(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseValueEnd(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.AttributeValue,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationOpen.ts
+var xmlDeclarationOpen_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$10 });
+function parse$10(chars, state) {
+	if (chars.value() === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace$1(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseClosingCornerBrace$1(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.OpenTagEnd,
+		value: state.accumulatedContent.value() + state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationClose.ts
+var xmlDeclarationClose_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$9 });
+function parse$9(chars, state) {
+	if (chars.value() === SPECIAL_CHAR.closingCorner) return parseClosingCornerBrace(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseClosingCornerBrace(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: true });
+	state.tokens.push({
+		type: TokenTypes.OpenTagEnd,
+		value: state.accumulatedContent.value() + state.decisionBuffer.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/doctypeAttributeBare.ts
+var doctypeAttributeBare_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$8 });
+function parse$8(chars, state) {
+	const value = chars.value();
+	if (isWhitespace(value) || value === SPECIAL_CHAR.closingCorner) return parseAttributeEnd(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseAttributeEnd(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.DoctypeAttributeValue,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeAttributes;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/attributeValueWrapped.ts
+var attributeValueWrapped_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$7 });
+function parse$7(chars, state) {
+	const wrapperChar = state.contextParams[TokenizerContextTypes.AttributeValueWrapped]?.wrapper;
+	if (chars.value() === wrapperChar) return parseWrapper$3(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper$3(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	const endWrapperPosition = position.range[1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValue,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	const range = [endWrapperPosition, endWrapperPosition + 1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValueWrapperEnd,
+		value: state.decisionBuffer.value(),
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/doctypeAttributeWrapped.ts
+var doctypeAttributeWrapped_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$6 });
+function parse$6(chars, state) {
+	if (chars.value() === state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped]?.wrapper) return parseWrapper$2(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper$2(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	const endWrapperPosition = position.range[1];
+	state.tokens.push({
+		type: TokenTypes.DoctypeAttributeValue,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	const range = [endWrapperPosition, endWrapperPosition + 1];
+	state.tokens.push({
+		type: TokenTypes.DoctypeAttributeWrapperEnd,
+		value: state.decisionBuffer.value(),
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.DoctypeAttributes;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationAttributes.ts
+var xmlDeclarationAttributes_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$5 });
+function parse$5(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.question || value === SPECIAL_CHAR.closingCorner) return parseXMLDeclarationClose(state);
+	if (value === XML_DECLARATION_END) return parseXMLDeclarationClose(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseXMLDeclarationClose(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	const endRange = [position.range[1], position.range[1] + XML_DECLARATION_END.length];
+	state.tokens.push({
+		type: TokenTypes.XMLDeclarationClose,
+		value: state.decisionBuffer.value(),
+		range: endRange,
+		loc: state.sourceCode.getLocationOf(endRange)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Data;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationAttributeKey.ts
+var xmlDeclarationAttributeKey_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$4 });
+function parse$4(chars, state) {
+	if (isKeyBreak(chars)) return parseKeyEnd(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function isKeyBreak(chars) {
+	const value = chars.value();
+	return value === SPECIAL_CHAR.equal || value === SPECIAL_CHAR.slash || value === SPECIAL_CHAR.closingCorner || isWhitespace(value);
+}
+function parseKeyEnd(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	state.tokens.push({
+		type: TokenTypes.XMLDeclarationAttributeKey,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.XMLDeclarationAttributes;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationAttributeValue.ts
+var xmlDeclarationAttributeValue_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$3 });
+function parse$3(chars, state) {
+	const value = chars.value();
+	if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) return parseWrapper$1(state);
+	if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) return parseTagEnd(state);
+	if (!isWhitespace(value)) return parseBare(state);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper$1(state) {
+	const wrapper = state.decisionBuffer.value();
+	const range = [state.sourceCode.index(), state.sourceCode.index() + 1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValueWrapperStart,
+		value: wrapper,
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.AttributeValueWrapped;
+	state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = { wrapper };
+	state.sourceCode.next();
+}
+function parseTagEnd(state) {
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+}
+function parseBare(state) {
+	state.accumulatedContent.replace(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.AttributeValueBare;
+	state.sourceCode.next();
+}
+
+//#endregion
+//#region src/tokenizer/handlers/xmlDeclarationAttributeValueWrapped.ts
+var xmlDeclarationAttributeValueWrapped_exports = /* @__PURE__ */ __exportAll({ parse: () => parse$2 });
+function parse$2(chars, state) {
+	const wrapperChar = state.contextParams[TokenizerContextTypes.AttributeValueWrapped]?.wrapper;
+	if (chars.value() === wrapperChar) return parseWrapper(state);
+	state.accumulatedContent.concatBuffer(state.decisionBuffer);
+	state.decisionBuffer.clear();
+	state.sourceCode.next();
+}
+function parseWrapper(state) {
+	const position = calculateTokenPosition(state, { keepBuffer: false });
+	const endWrapperPosition = position.range[1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValue,
+		value: state.accumulatedContent.value(),
+		range: position.range,
+		loc: position.loc
+	});
+	const range = [endWrapperPosition, endWrapperPosition + 1];
+	state.tokens.push({
+		type: TokenTypes.AttributeValueWrapperEnd,
+		value: state.decisionBuffer.value(),
+		range,
+		loc: state.sourceCode.getLocationOf(range)
+	});
+	state.accumulatedContent.clear();
+	state.decisionBuffer.clear();
+	state.currentContext = TokenizerContextTypes.Attributes;
+	state.sourceCode.next();
+	state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = void 0;
+}
+
+//#endregion
+//#region src/tokenizer/handlers/index.ts
+const noop = { parse: () => {} };
+
+//#endregion
+//#region src/tokenizer/chars.ts
+var Chars = class {
+	constructor(value, range) {
+		this.value = value;
+		this.range = range;
+	}
+	concat(chars) {
+		this.value += chars.value;
+		this.range[1] = chars.range[1];
+	}
+	equals(chars) {
+		return this.value === chars;
+	}
+	length() {
+		return this.value.length;
+	}
+};
+
+//#endregion
+//#region src/tokenizer/sourceCode.ts
+var SourceCode = class {
+	charsList;
+	charsIndex = 0;
+	constructor(source) {
+		this.source = source;
+		this.charsList = this.createCharsList();
+	}
+	getLocationOf(range) {
+		return {
+			start: getLineInfo(this.source, range[0]),
+			end: getLineInfo(this.source, range[1])
+		};
+	}
+	current() {
+		return this.charsList[this.charsIndex];
+	}
+	next() {
+		this.charsIndex++;
+	}
+	prev() {
+		this.charsIndex--;
+	}
+	isEof() {
+		return this.charsIndex >= this.charsList.length;
+	}
+	index() {
+		return this.current().range[1] - 1;
+	}
+	createCharsList() {
+		const charsList = [];
+		let sourceIndex = 0;
+		while (sourceIndex < this.source.length) {
+			charsList.push(new Chars(this.source[sourceIndex], [sourceIndex, sourceIndex + 1]));
+			sourceIndex++;
+		}
+		return charsList;
+	}
+};
+
+//#endregion
+//#region src/tokenizer/tokenize.ts
+const contextHandlers = {
+	[TokenizerContextTypes.Data]: data_exports,
+	[TokenizerContextTypes.XMLDeclarationOpen]: xmlDeclarationOpen_exports,
+	[TokenizerContextTypes.XMLDeclarationClose]: xmlDeclarationClose_exports,
+	[TokenizerContextTypes.XMLDeclarationAttributes]: xmlDeclarationAttributes_exports,
+	[TokenizerContextTypes.XMLDeclarationAttributeKey]: xmlDeclarationAttributeKey_exports,
+	[TokenizerContextTypes.XMLDeclarationAttributeValue]: xmlDeclarationAttributeValue_exports,
+	[TokenizerContextTypes.XMLDeclarationAttributeValueWrapped]: xmlDeclarationAttributeValueWrapped_exports,
+	[TokenizerContextTypes.Attributes]: attributes_exports,
+	[TokenizerContextTypes.AttributeKey]: attributeKey_exports,
+	[TokenizerContextTypes.AttributeValue]: attributeValue_exports,
+	[TokenizerContextTypes.AttributeValueBare]: attributeValueBare_exports,
+	[TokenizerContextTypes.AttributeValueWrapped]: attributeValueWrapped_exports,
+	[TokenizerContextTypes.OpenTagStart]: openTagStart_exports,
+	[TokenizerContextTypes.OpenTagEnd]: openTagEnd_exports,
+	[TokenizerContextTypes.CloseTag]: closeTag_exports,
+	[TokenizerContextTypes.DoctypeOpen]: doctypeOpen_exports,
+	[TokenizerContextTypes.DoctypeClose]: doctypeClose_exports,
+	[TokenizerContextTypes.DoctypeAttributes]: doctypeAttributes_exports,
+	[TokenizerContextTypes.DoctypeAttributeBare]: doctypeAttributeBare_exports,
+	[TokenizerContextTypes.DoctypeAttributeWrapped]: doctypeAttributeWrapped_exports,
+	[TokenizerContextTypes.CommentContent]: commentContent_exports,
+	[TokenizerContextTypes.CommentOpen]: noop,
+	[TokenizerContextTypes.CommentClose]: noop
+};
+function tokenizeChars(state) {
+	while (!state.sourceCode.isEof()) {
+		const handler$1 = contextHandlers[state.currentContext];
+		state.decisionBuffer.concat(state.sourceCode.current());
+		handler$1.parse(state.decisionBuffer, state);
+	}
+	const handler = contextHandlers[state.currentContext];
+	state.sourceCode.prev();
+	if (handler.handleContentEnd !== void 0) handler.handleContentEnd(state);
+}
+function tokenize(source) {
+	const tokens = [];
+	const state = {
+		contextParams: {},
+		currentContext: TokenizerContextTypes.Data,
+		sourceCode: new SourceCode(source),
+		decisionBuffer: new CharsBuffer(),
+		accumulatedContent: new CharsBuffer(),
+		tokens: { push(token) {
+			tokens.push(token);
+		} }
+	};
+	tokenizeChars(state);
+	return {
+		state,
+		tokens
+	};
+}
+
+//#endregion
+//#region src/parser/parse.ts
+function parse$1(source, _options = {}) {
+	const { tokens } = tokenize(source);
+	const { ast } = constructTree(tokens);
+	return {
+		ast: clearParent(ast),
+		tokens
+	};
+}
+
+//#endregion
+//#region src/visitorKeys.ts
+const keys = {
+	Program: ["body"],
+	Document: ["children"],
+	XMLDeclaration: [],
+	XMLDeclarationOpen: [],
+	XMLDeclarationClose: [],
+	XMLDeclarationAttribute: ["key", "value"],
+	XMLDeclarationAttributeKey: [],
+	XMLDeclarationAttributeValue: [],
+	XMLDeclarationAttributeValueWrapperStart: [],
+	XMLDeclarationAttributeValueWrapperEnd: [],
+	Doctype: [
+		"open",
+		"close",
+		"attributes"
+	],
+	DoctypeOpen: [],
+	DoctypeClose: [],
+	DoctypeAttribute: ["key", "value"],
+	DoctypeAttributeValue: ["value"],
+	DoctypeAttributeWrapperEnd: [],
+	DoctypeAttributeWrapperStart: [],
+	Attribute: ["key", "value"],
+	AttributeKey: ["value"],
+	AttributeValue: ["value"],
+	AttributeValueWrapperEnd: [],
+	AttributeValueWrapperStart: [],
+	Tag: ["children", "attributes"],
+	OpenTagEnd: [],
+	OpenTagStart: [],
+	CloseTag: [],
+	Comment: [
+		"open",
+		"close",
+		"value"
+	],
+	CommentOpen: [],
+	CommentClose: [],
+	CommentContent: [],
+	Text: []
+};
+let vistorKeysCache = null;
+function getVisitorKeys() {
+	if (!vistorKeysCache) vistorKeysCache = unionWith(keys);
+	return vistorKeysCache;
+}
+const visitorKeys = getVisitorKeys();
+
+//#endregion
+//#region src/parser/traverse.ts
+function traverse(node, visitor) {
+	if (!node) return;
+	visitor(node);
+	const keys$1 = visitorKeys[node.type];
+	if (!keys$1 || keys$1.length <= 0) return;
+	keys$1.forEach((key) => {
+		const value = node[key];
+		if (value) if (Array.isArray(value)) value.forEach((n) => traverse(n, visitor));
+		else traverse(value, visitor);
+	});
+}
+
+//#endregion
+//#region src/parser/parseForESLint.ts
+function parseForESLint(source, options = {}) {
+	const { ast, tokens } = parse$1(source, options);
+	const programNode = {
+		type: NodeTypes.Program,
+		body: [ast],
+		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
+		});
+	});
+	return {
+		ast: programNode,
+		visitorKeys,
+		scopeManager: null,
+		services: { isSVG: true }
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const name = meta.name;
+const VisitorKeys = visitorKeys;
+function parse(code, options = {}) {
+	return parseForESLint(code, options).ast;
+}
+
+//#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 };