@salesforce-ux/eslint-plugin-slds 0.0.1

package/build/index.js

@@ -0,0 +1,3310 @@
+'use strict';
+
+var require$$0 = require('fs');
+var require$$1 = require('path');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var dist$1 = {};
+
+var parser$1 = {};
+
+var dist = {};
+
+var parser = {};
+
+var parse = {};
+
+var treeConstructor = {};
+
+var constructTree = {};
+
+var constants = {};
+
+var astTypes = {};
+
+var hasRequiredAstTypes;
+
+function requireAstTypes () {
+	if (hasRequiredAstTypes) return astTypes;
+	hasRequiredAstTypes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.AstTypes = void 0;
+		(function (AstTypes) {
+		    AstTypes["Document"] = "Document";
+		    AstTypes["Tag"] = "Tag";
+		    AstTypes["Text"] = "Text";
+		    AstTypes["Doctype"] = "Doctype";
+		    AstTypes["Comment"] = "Comment";
+		    AstTypes["Script"] = "Script";
+		    AstTypes["Style"] = "Style";
+		})(exports.AstTypes || (exports.AstTypes = {})); 
+	} (astTypes));
+	return astTypes;
+}
+
+var tokenizerContextTypes = {};
+
+var hasRequiredTokenizerContextTypes;
+
+function requireTokenizerContextTypes () {
+	if (hasRequiredTokenizerContextTypes) return tokenizerContextTypes;
+	hasRequiredTokenizerContextTypes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.TokenizerContextTypes = void 0;
+		(function (TokenizerContextTypes) {
+		    TokenizerContextTypes["Data"] = "Data";
+		    TokenizerContextTypes["OpenTagStart"] = "OpenTagStart";
+		    TokenizerContextTypes["CloseTag"] = "CloseTag";
+		    TokenizerContextTypes["Attributes"] = "Attributes";
+		    TokenizerContextTypes["OpenTagEnd"] = "OpenTagEnd";
+		    TokenizerContextTypes["AttributeKey"] = "AttributeKey";
+		    TokenizerContextTypes["AttributeValue"] = "AttributeValue";
+		    TokenizerContextTypes["AttributeValueBare"] = "AttributeValueBare";
+		    TokenizerContextTypes["AttributeValueWrapped"] = "AttributeValueWrapped";
+		    TokenizerContextTypes["ScriptContent"] = "ScriptContent";
+		    TokenizerContextTypes["StyleContent"] = "StyleContent";
+		    TokenizerContextTypes["DoctypeOpen"] = "DoctypeOpen";
+		    TokenizerContextTypes["DoctypeClose"] = "DoctypeClose";
+		    TokenizerContextTypes["DoctypeAttributes"] = "DoctypeAttributes";
+		    TokenizerContextTypes["DoctypeAttributeWrapped"] = "DoctypeAttributeWrapped";
+		    TokenizerContextTypes["DoctypeAttributeBare"] = "DoctypeAttributeBare";
+		    TokenizerContextTypes["CommentOpen"] = "CommentOpen";
+		    TokenizerContextTypes["CommentContent"] = "CommentContent";
+		    TokenizerContextTypes["CommentClose"] = "CommentClose";
+		})(exports.TokenizerContextTypes || (exports.TokenizerContextTypes = {})); 
+	} (tokenizerContextTypes));
+	return tokenizerContextTypes;
+}
+
+var regex = {};
+
+var hasRequiredRegex;
+
+function requireRegex () {
+	if (hasRequiredRegex) return regex;
+	hasRequiredRegex = 1;
+	Object.defineProperty(regex, "__esModule", { value: true });
+	regex.CLOSE_TAG_NAME_PATTERN = regex.OPEN_TAG_NAME_PATTERN = regex.CLOSING_STYLE_TAG_PATTERN = regex.CLOSING_SCRIPT_TAG_PATTERN = regex.INCOMPLETE_CLOSING_TAG_PATTERN = void 0;
+	regex.INCOMPLETE_CLOSING_TAG_PATTERN = /<\/[^>]+$/;
+	regex.CLOSING_SCRIPT_TAG_PATTERN = /<\/script\s*>/i;
+	regex.CLOSING_STYLE_TAG_PATTERN = /<\/style\s*>/i;
+	regex.OPEN_TAG_NAME_PATTERN = /^<(\S+)/;
+	regex.CLOSE_TAG_NAME_PATTERN = /^<\/((?:.|\n)*)>$/;
+	return regex;
+}
+
+var tokenTypes = {};
+
+var hasRequiredTokenTypes;
+
+function requireTokenTypes () {
+	if (hasRequiredTokenTypes) return tokenTypes;
+	hasRequiredTokenTypes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.TokenTypes = void 0;
+		(function (TokenTypes) {
+		    TokenTypes["Text"] = "Text";
+		    TokenTypes["OpenTagStart"] = "OpenTagStart";
+		    TokenTypes["OpenTagEnd"] = "OpenTagEnd";
+		    TokenTypes["CloseTag"] = "CloseTag";
+		    TokenTypes["AttributeKey"] = "AttributeKey";
+		    TokenTypes["AttributeAssignment"] = "AttributeAssignment";
+		    TokenTypes["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
+		    TokenTypes["AttributeValue"] = "AttributeValue";
+		    TokenTypes["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
+		    TokenTypes["DoctypeOpen"] = "DoctypeOpen";
+		    TokenTypes["DoctypeAttributeValue"] = "DoctypeAttributeValue";
+		    TokenTypes["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
+		    TokenTypes["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
+		    TokenTypes["DoctypeClose"] = "DoctypeClose";
+		    TokenTypes["CommentOpen"] = "CommentOpen";
+		    TokenTypes["CommentContent"] = "CommentContent";
+		    TokenTypes["CommentClose"] = "CommentClose";
+		    TokenTypes["OpenScriptTagStart"] = "OpenScriptTagStart";
+		    TokenTypes["OpenScriptTagEnd"] = "OpenScriptTagEnd";
+		    TokenTypes["ScriptTagContent"] = "ScriptTagContent";
+		    TokenTypes["CloseScriptTag"] = "CloseScriptTag";
+		    TokenTypes["OpenStyleTagStart"] = "OpenStyleTagStart";
+		    TokenTypes["OpenStyleTagEnd"] = "OpenStyleTagEnd";
+		    TokenTypes["StyleTagContent"] = "StyleTagContent";
+		    TokenTypes["CloseStyleTag"] = "CloseStyleTag";
+		})(exports.TokenTypes || (exports.TokenTypes = {})); 
+	} (tokenTypes));
+	return tokenTypes;
+}
+
+var nodeTypes = {};
+
+var hasRequiredNodeTypes;
+
+function requireNodeTypes () {
+	if (hasRequiredNodeTypes) return nodeTypes;
+	hasRequiredNodeTypes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.NodeTypes = void 0;
+		(function (NodeTypes) {
+		    NodeTypes["Document"] = "Document";
+		    NodeTypes["Tag"] = "Tag";
+		    NodeTypes["Text"] = "Text";
+		    NodeTypes["Doctype"] = "Doctype";
+		    NodeTypes["Comment"] = "Comment";
+		    NodeTypes["CommentOpen"] = "CommentOpen";
+		    NodeTypes["CommentClose"] = "CommentClose";
+		    NodeTypes["CommentContent"] = "CommentContent";
+		    NodeTypes["Attribute"] = "Attribute";
+		    NodeTypes["AttributeKey"] = "AttributeKey";
+		    NodeTypes["AttributeValue"] = "AttributeValue";
+		    NodeTypes["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
+		    NodeTypes["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
+		    NodeTypes["CloseTag"] = "CloseTag";
+		    NodeTypes["OpenTagEnd"] = "OpenTagEnd";
+		    NodeTypes["OpenTagStart"] = "OpenTagStart";
+		    NodeTypes["DoctypeOpen"] = "DoctypeOpen";
+		    NodeTypes["DoctypeAttribute"] = "DoctypeAttribute";
+		    NodeTypes["DoctypeClose"] = "DoctypeClose";
+		    NodeTypes["ScriptTag"] = "ScriptTag";
+		    NodeTypes["OpenScriptTagStart"] = "OpenScriptTagStart";
+		    NodeTypes["OpenScriptTagEnd"] = "OpenScriptTagEnd";
+		    NodeTypes["ScriptTagContent"] = "ScriptTagContent";
+		    NodeTypes["StyleTag"] = "StyleTag";
+		    NodeTypes["OpenStyleTagStart"] = "OpenStyleTagStart";
+		    NodeTypes["OpenStyleTagEnd"] = "OpenStyleTagEnd";
+		    NodeTypes["StyleTagContent"] = "StyleTagContent";
+		    NodeTypes["CloseStyleTag"] = "CloseStyleTag";
+		    NodeTypes["CloseScriptTag"] = "CloseScriptTag";
+		    NodeTypes["DoctypeAttributeValue"] = "DoctypeAttributeValue";
+		    NodeTypes["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
+		    NodeTypes["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
+		})(exports.NodeTypes || (exports.NodeTypes = {})); 
+	} (nodeTypes));
+	return nodeTypes;
+}
+
+var constructTreeContextTypes = {};
+
+var hasRequiredConstructTreeContextTypes;
+
+function requireConstructTreeContextTypes () {
+	if (hasRequiredConstructTreeContextTypes) return constructTreeContextTypes;
+	hasRequiredConstructTreeContextTypes = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.ConstructTreeContextTypes = void 0;
+		(function (ConstructTreeContextTypes) {
+		    ConstructTreeContextTypes["TagContent"] = "TagContent";
+		    ConstructTreeContextTypes["Tag"] = "Tag";
+		    ConstructTreeContextTypes["TagName"] = "TagName";
+		    ConstructTreeContextTypes["Attributes"] = "Attributes";
+		    ConstructTreeContextTypes["Attribute"] = "Attribute";
+		    ConstructTreeContextTypes["AttributeValue"] = "AttributeValue";
+		    ConstructTreeContextTypes["Comment"] = "Comment";
+		    ConstructTreeContextTypes["Doctype"] = "Doctype";
+		    ConstructTreeContextTypes["DoctypeAttributes"] = "DoctypeAttributes";
+		    ConstructTreeContextTypes["DoctypeAttribute"] = "DoctypeAttribute";
+		    ConstructTreeContextTypes["ScriptTag"] = "ScriptTag";
+		    ConstructTreeContextTypes["StyleTag"] = "StyleTag";
+		})(exports.ConstructTreeContextTypes || (exports.ConstructTreeContextTypes = {})); 
+	} (constructTreeContextTypes));
+	return constructTreeContextTypes;
+}
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	(function (exports) {
+		var __createBinding = (constants && constants.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (constants && constants.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireAstTypes(), exports);
+		__exportStar(requireTokenizerContextTypes(), exports);
+		__exportStar(requireRegex(), exports);
+		__exportStar(requireTokenTypes(), exports);
+		__exportStar(requireNodeTypes(), exports);
+		__exportStar(requireConstructTreeContextTypes(), exports); 
+	} (constants));
+	return constants;
+}
+
+var utils = {};
+
+var calculateTokenCharactersRange = {};
+
+var hasRequiredCalculateTokenCharactersRange;
+
+function requireCalculateTokenCharactersRange () {
+	if (hasRequiredCalculateTokenCharactersRange) return calculateTokenCharactersRange;
+	hasRequiredCalculateTokenCharactersRange = 1;
+	Object.defineProperty(calculateTokenCharactersRange, "__esModule", { value: true });
+	calculateTokenCharactersRange.calculateTokenCharactersRange = void 0;
+	function calculateTokenCharactersRange$1(state, { keepBuffer }) {
+	    const startPosition = state.caretPosition -
+	        (state.accumulatedContent.length - 1) -
+	        state.decisionBuffer.length;
+	    let endPosition;
+	    if (!keepBuffer) {
+	        endPosition = state.caretPosition - state.decisionBuffer.length;
+	    }
+	    else {
+	        endPosition = state.caretPosition;
+	    }
+	    return [startPosition, endPosition + 1];
+	}
+	calculateTokenCharactersRange.calculateTokenCharactersRange = calculateTokenCharactersRange$1;
+	return calculateTokenCharactersRange;
+}
+
+var isWhitespace = {};
+
+var hasRequiredIsWhitespace;
+
+function requireIsWhitespace () {
+	if (hasRequiredIsWhitespace) return isWhitespace;
+	hasRequiredIsWhitespace = 1;
+	Object.defineProperty(isWhitespace, "__esModule", { value: true });
+	isWhitespace.isWhitespace = void 0;
+	function isWhitespace$1(char) {
+	    return char === " " || char === "\n" || char === "\t" || char === "\r";
+	}
+	isWhitespace.isWhitespace = isWhitespace$1;
+	return isWhitespace;
+}
+
+var parseOpenTagName = {};
+
+var hasRequiredParseOpenTagName;
+
+function requireParseOpenTagName () {
+	if (hasRequiredParseOpenTagName) return parseOpenTagName;
+	hasRequiredParseOpenTagName = 1;
+	Object.defineProperty(parseOpenTagName, "__esModule", { value: true });
+	parseOpenTagName.parseOpenTagName = void 0;
+	const constants_1 = requireConstants();
+	function parseOpenTagName$1(openTagStartTokenContent) {
+	    const match = openTagStartTokenContent.match(constants_1.OPEN_TAG_NAME_PATTERN);
+	    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();
+	}
+	parseOpenTagName.parseOpenTagName = parseOpenTagName$1;
+	return parseOpenTagName;
+}
+
+var parseCloseTagName = {};
+
+var hasRequiredParseCloseTagName;
+
+function requireParseCloseTagName () {
+	if (hasRequiredParseCloseTagName) return parseCloseTagName;
+	hasRequiredParseCloseTagName = 1;
+	Object.defineProperty(parseCloseTagName, "__esModule", { value: true });
+	parseCloseTagName.parseCloseTagName = void 0;
+	const constants_1 = requireConstants();
+	function parseCloseTagName$1(closeTagTokenContent) {
+	    const match = closeTagTokenContent.match(constants_1.CLOSE_TAG_NAME_PATTERN);
+	    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();
+	}
+	parseCloseTagName.parseCloseTagName = parseCloseTagName$1;
+	return parseCloseTagName;
+}
+
+var clearParent = {};
+
+var hasRequiredClearParent;
+
+function requireClearParent () {
+	if (hasRequiredClearParent) return clearParent;
+	hasRequiredClearParent = 1;
+	Object.defineProperty(clearParent, "__esModule", { value: true });
+	clearParent.clearParent = void 0;
+	function clearParent$1(ast) {
+	    const cleanAst = ast;
+	    delete cleanAst.parentRef;
+	    if (Array.isArray(ast.children)) {
+	        // @ts-ignore
+	        cleanAst.children = ast.children.map((node) => {
+	            return clearParent$1(node);
+	        });
+	    }
+	    return cleanAst;
+	}
+	clearParent.clearParent = clearParent$1;
+	return clearParent;
+}
+
+var calculateTokenLocation = {};
+
+var getLineInfo = {};
+
+var hasRequiredGetLineInfo;
+
+function requireGetLineInfo () {
+	if (hasRequiredGetLineInfo) return getLineInfo;
+	hasRequiredGetLineInfo = 1;
+	//https://github.com/acornjs/acorn/blob/master/acorn/src/whitespace.js
+	Object.defineProperty(getLineInfo, "__esModule", { value: true });
+	getLineInfo.getLineInfo = void 0;
+	function isNewLine(code) {
+	    return code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+	}
+	function nextLineBreak(code, from, end = code.length) {
+	    for (let i = from; i < end; i++) {
+	        const next = code.charCodeAt(i);
+	        if (isNewLine(next))
+	            return i < end - 1 && next === 13 && code.charCodeAt(i + 1) === 10
+	                ? i + 2
+	                : i + 1;
+	    }
+	    return -1;
+	}
+	function getLineInfo$1(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;
+	    }
+	}
+	getLineInfo.getLineInfo = getLineInfo$1;
+	return getLineInfo;
+}
+
+var hasRequiredCalculateTokenLocation;
+
+function requireCalculateTokenLocation () {
+	if (hasRequiredCalculateTokenLocation) return calculateTokenLocation;
+	hasRequiredCalculateTokenLocation = 1;
+	Object.defineProperty(calculateTokenLocation, "__esModule", { value: true });
+	calculateTokenLocation.calculateTokenLocation = void 0;
+	const get_line_info_1 = requireGetLineInfo();
+	function calculateTokenLocation$1(source, range) {
+	    return {
+	        start: (0, get_line_info_1.getLineInfo)(source, range[0]),
+	        end: (0, get_line_info_1.getLineInfo)(source, range[1]),
+	    };
+	}
+	calculateTokenLocation.calculateTokenLocation = calculateTokenLocation$1;
+	return calculateTokenLocation;
+}
+
+var calculateTokenPosition = {};
+
+var hasRequiredCalculateTokenPosition;
+
+function requireCalculateTokenPosition () {
+	if (hasRequiredCalculateTokenPosition) return calculateTokenPosition;
+	hasRequiredCalculateTokenPosition = 1;
+	Object.defineProperty(calculateTokenPosition, "__esModule", { value: true });
+	calculateTokenPosition.calculateTokenPosition = void 0;
+	const calculate_token_characters_range_1 = requireCalculateTokenCharactersRange();
+	const calculate_token_location_1 = requireCalculateTokenLocation();
+	function calculateTokenPosition$1(state, options) {
+	    const range = (0, calculate_token_characters_range_1.calculateTokenCharactersRange)(state, options);
+	    const loc = (0, calculate_token_location_1.calculateTokenLocation)(state.source, range);
+	    return {
+	        range,
+	        loc,
+	    };
+	}
+	calculateTokenPosition.calculateTokenPosition = calculateTokenPosition$1;
+	return calculateTokenPosition;
+}
+
+var last = {};
+
+var hasRequiredLast;
+
+function requireLast () {
+	if (hasRequiredLast) return last;
+	hasRequiredLast = 1;
+	Object.defineProperty(last, "__esModule", { value: true });
+	last.last = void 0;
+	function last$1(items) {
+	    return items[items.length - 1];
+	}
+	last.last = last$1;
+	return last;
+}
+
+var cloneRange = {};
+
+var hasRequiredCloneRange;
+
+function requireCloneRange () {
+	if (hasRequiredCloneRange) return cloneRange;
+	hasRequiredCloneRange = 1;
+	Object.defineProperty(cloneRange, "__esModule", { value: true });
+	cloneRange.cloneRange = void 0;
+	function cloneRange$1(range) {
+	    return [range[0], range[1]];
+	}
+	cloneRange.cloneRange = cloneRange$1;
+	return cloneRange;
+}
+
+var createNodeFrom = {};
+
+var cloneLocation = {};
+
+var hasRequiredCloneLocation;
+
+function requireCloneLocation () {
+	if (hasRequiredCloneLocation) return cloneLocation;
+	hasRequiredCloneLocation = 1;
+	Object.defineProperty(cloneLocation, "__esModule", { value: true });
+	cloneLocation.cloneLocation = void 0;
+	function cloneLocation$1(loc) {
+	    return {
+	        start: {
+	            line: loc.start.line,
+	            column: loc.start.column,
+	        },
+	        end: {
+	            line: loc.end.line,
+	            column: loc.end.column,
+	        },
+	    };
+	}
+	cloneLocation.cloneLocation = cloneLocation$1;
+	return cloneLocation;
+}
+
+var hasRequiredCreateNodeFrom;
+
+function requireCreateNodeFrom () {
+	if (hasRequiredCreateNodeFrom) return createNodeFrom;
+	hasRequiredCreateNodeFrom = 1;
+	Object.defineProperty(createNodeFrom, "__esModule", { value: true });
+	createNodeFrom.createNodeFrom = void 0;
+	const clone_location_1 = requireCloneLocation();
+	const clone_range_1 = requireCloneRange();
+	function createNodeFrom$1(token) {
+	    const loc = (0, clone_location_1.cloneLocation)(token.loc);
+	    const range = (0, clone_range_1.cloneRange)(token.range);
+	    return {
+	        type: token.type,
+	        value: token.value,
+	        loc,
+	        range,
+	    };
+	}
+	createNodeFrom.createNodeFrom = createNodeFrom$1;
+	return createNodeFrom;
+}
+
+var updateNodeEnd = {};
+
+var hasRequiredUpdateNodeEnd;
+
+function requireUpdateNodeEnd () {
+	if (hasRequiredUpdateNodeEnd) return updateNodeEnd;
+	hasRequiredUpdateNodeEnd = 1;
+	Object.defineProperty(updateNodeEnd, "__esModule", { value: true });
+	updateNodeEnd.updateNodeEnd = void 0;
+	function updateNodeEnd$1(node, token) {
+	    node.range[1] = token.range[1];
+	    node.loc.end = Object.assign({}, token.loc.end);
+	}
+	updateNodeEnd.updateNodeEnd = updateNodeEnd$1;
+	return updateNodeEnd;
+}
+
+var first = {};
+
+var hasRequiredFirst;
+
+function requireFirst () {
+	if (hasRequiredFirst) return first;
+	hasRequiredFirst = 1;
+	Object.defineProperty(first, "__esModule", { value: true });
+	first.first = void 0;
+	function first$1(items) {
+	    return items[0];
+	}
+	first.first = first$1;
+	return first;
+}
+
+var initIfNone = {};
+
+var hasRequiredInitIfNone;
+
+function requireInitIfNone () {
+	if (hasRequiredInitIfNone) return initIfNone;
+	hasRequiredInitIfNone = 1;
+	Object.defineProperty(initIfNone, "__esModule", { value: true });
+	initIfNone.initAttributesIfNone = initIfNone.initChildrenIfNone = void 0;
+	function initChildrenIfNone(node) {
+	    /* istanbul ignore next */
+	    if (!node.children) {
+	        node.children = [];
+	    }
+	}
+	initIfNone.initChildrenIfNone = initChildrenIfNone;
+	function initAttributesIfNone(node) {
+	    /* istanbul ignore next */
+	    if (!node.attributes) {
+	        node.attributes = [];
+	    }
+	}
+	initIfNone.initAttributesIfNone = initAttributesIfNone;
+	return initIfNone;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		var __createBinding = (utils && utils.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (utils && utils.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireCalculateTokenCharactersRange(), exports);
+		__exportStar(requireIsWhitespace(), exports);
+		__exportStar(requireParseOpenTagName(), exports);
+		__exportStar(requireParseCloseTagName(), exports);
+		__exportStar(requireClearParent(), exports);
+		__exportStar(requireCalculateTokenLocation(), exports);
+		__exportStar(requireCalculateTokenPosition(), exports);
+		__exportStar(requireLast(), exports);
+		__exportStar(requireCloneRange(), exports);
+		__exportStar(requireCreateNodeFrom(), exports);
+		__exportStar(requireUpdateNodeEnd(), exports);
+		__exportStar(requireGetLineInfo(), exports);
+		__exportStar(requireFirst(), exports);
+		__exportStar(requireCloneLocation(), exports);
+		__exportStar(requireInitIfNone(), exports); 
+	} (utils));
+	return utils;
+}
+
+var handlers$1 = {};
+
+var attributeValue$1 = {};
+
+var hasRequiredAttributeValue$1;
+
+function requireAttributeValue$1 () {
+	if (hasRequiredAttributeValue$1) return attributeValue$1;
+	hasRequiredAttributeValue$1 = 1;
+	Object.defineProperty(attributeValue$1, "__esModule", { value: true });
+	attributeValue$1.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const VALUE_END_TOKENS = [
+	    constants_1.TokenTypes.OpenTagEnd,
+	    constants_1.TokenTypes.AttributeKey,
+	    constants_1.TokenTypes.AttributeAssignment,
+	    constants_1.TokenTypes.OpenScriptTagEnd,
+	    constants_1.TokenTypes.OpenStyleTagEnd,
+	];
+	function getLastAttribute(state) {
+	    const attributes = state.currentNode.attributes;
+	    return attributes[attributes.length - 1];
+	}
+	function handleValueEnd(state) {
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function handleAttributeValue(state, token) {
+	    const attribute = getLastAttribute(state);
+	    attribute.value = (0, utils_1.createNodeFrom)(token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeValueWrapperStart(state, token) {
+	    const attribute = getLastAttribute(state);
+	    attribute.startWrapper = (0, utils_1.createNodeFrom)(token);
+	    if (!attribute.key) {
+	        attribute.range = (0, utils_1.cloneRange)(token.range);
+	        attribute.loc = (0, utils_1.cloneLocation)(token.loc);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeValueWrapperEnd(state, token) {
+	    const attribute = getLastAttribute(state);
+	    attribute.endWrapper = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(attribute, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (VALUE_END_TOKENS.indexOf(token.type) !== -1) {
+	        return handleValueEnd(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.AttributeValue) {
+	        return handleAttributeValue(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.AttributeValueWrapperStart) {
+	        return handleAttributeValueWrapperStart(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.AttributeValueWrapperEnd) {
+	        return handleAttributeValueWrapperEnd(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	attributeValue$1.construct = construct;
+	return attributeValue$1;
+}
+
+var attributes$1 = {};
+
+var hasRequiredAttributes$1;
+
+function requireAttributes$1 () {
+	if (hasRequiredAttributes$1) return attributes$1;
+	hasRequiredAttributes$1 = 1;
+	Object.defineProperty(attributes$1, "__esModule", { value: true });
+	attributes$1.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTE_START_TOKENS = [
+	    constants_1.TokenTypes.AttributeKey,
+	    constants_1.TokenTypes.AttributeAssignment,
+	];
+	const ATTRIBUTES_END_TOKENS = [
+	    constants_1.TokenTypes.OpenTagEnd,
+	    constants_1.TokenTypes.OpenStyleTagEnd,
+	    constants_1.TokenTypes.OpenScriptTagEnd,
+	];
+	function handlerAttributeStart(state, token) {
+	    (0, utils_1.initAttributesIfNone)(state.currentNode);
+	    // new empty attribute
+	    state.currentNode.attributes.push({
+	        type: constants_1.NodeTypes.Attribute,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	    });
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Attribute,
+	    };
+	    return state;
+	}
+	function handleOpenTagEnd(state) {
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (ATTRIBUTE_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handlerAttributeStart(state, token);
+	    }
+	    if (ATTRIBUTES_END_TOKENS.indexOf(token.type) !== -1) {
+	        return handleOpenTagEnd(state);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	attributes$1.construct = construct;
+	return attributes$1;
+}
+
+var attribute = {};
+
+var hasRequiredAttribute;
+
+function requireAttribute () {
+	if (hasRequiredAttribute) return attribute;
+	hasRequiredAttribute = 1;
+	Object.defineProperty(attribute, "__esModule", { value: true });
+	attribute.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const OPEN_TAG_END_TOKENS = [
+	    constants_1.TokenTypes.OpenTagEnd,
+	    constants_1.TokenTypes.OpenScriptTagEnd,
+	    constants_1.TokenTypes.OpenStyleTagEnd,
+	];
+	function getLastAttribute(state) {
+	    const attributes = state.currentNode.attributes;
+	    return attributes[attributes.length - 1];
+	}
+	function handleOpenTagEnd(state) {
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function handleAttributeKey(state, token) {
+	    const attribute = getLastAttribute(state);
+	    if (attribute.key !== undefined || attribute.value !== undefined) {
+	        state.currentContext = state.currentContext.parentRef;
+	        return state;
+	    }
+	    attribute.key = (0, utils_1.createNodeFrom)(token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeAssignment(state) {
+	    const attribute = getLastAttribute(state);
+	    if (attribute.value !== undefined) {
+	        state.currentContext = state.currentContext.parentRef;
+	        return state;
+	    }
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.AttributeValue,
+	    };
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (OPEN_TAG_END_TOKENS.indexOf(token.type) !== -1) {
+	        return handleOpenTagEnd(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.AttributeKey) {
+	        return handleAttributeKey(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.AttributeAssignment) {
+	        return handleAttributeAssignment(state);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	attribute.construct = construct;
+	return attribute;
+}
+
+var comment = {};
+
+var hasRequiredComment;
+
+function requireComment () {
+	if (hasRequiredComment) return comment;
+	hasRequiredComment = 1;
+	Object.defineProperty(comment, "__esModule", { value: true });
+	comment.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function handleCommentOpen(state, token) {
+	    state.currentNode.open = (0, utils_1.createNodeFrom)(token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleCommentContent(state, token) {
+	    state.currentNode.value = (0, utils_1.createNodeFrom)(token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleCommentClose(state, token) {
+	    state.currentNode.close = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.currentNode = state.currentNode.parentRef;
+	    state.currentContext = state.currentContext.parentRef;
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.CommentOpen) {
+	        return handleCommentOpen(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CommentContent) {
+	        return handleCommentContent(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CommentClose) {
+	        return handleCommentClose(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	comment.construct = construct;
+	return comment;
+}
+
+var doctypeAttribute = {};
+
+var hasRequiredDoctypeAttribute;
+
+function requireDoctypeAttribute () {
+	if (hasRequiredDoctypeAttribute) return doctypeAttribute;
+	hasRequiredDoctypeAttribute = 1;
+	Object.defineProperty(doctypeAttribute, "__esModule", { value: true });
+	doctypeAttribute.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function getLastAttribute(state) {
+	    const attributes = state.currentNode.attributes;
+	    return attributes[attributes.length - 1];
+	}
+	function handleDoctypeClose(state) {
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function handleAttributeValue(state, token) {
+	    const attribute = getLastAttribute(state);
+	    if (attribute.value !== undefined) {
+	        state.currentContext = state.currentContext.parentRef;
+	        return state;
+	    }
+	    attribute.value = (0, utils_1.createNodeFrom)(token);
+	    if (!attribute.startWrapper) {
+	        attribute.range = (0, utils_1.cloneRange)(token.range);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeWrapperStart(state, token) {
+	    const attribute = getLastAttribute(state);
+	    if (attribute.value !== undefined) {
+	        state.currentContext = state.currentContext.parentRef;
+	        return state;
+	    }
+	    attribute.startWrapper = (0, utils_1.createNodeFrom)(token);
+	    attribute.range = (0, utils_1.cloneRange)(token.range);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeWrapperEnd(state, token) {
+	    const attribute = getLastAttribute(state);
+	    attribute.endWrapper = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(attribute, token);
+	    state.currentContext = state.currentContext.parentRef;
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.DoctypeClose) {
+	        return handleDoctypeClose(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.DoctypeAttributeWrapperStart) {
+	        return handleAttributeWrapperStart(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.DoctypeAttributeWrapperEnd) {
+	        return handleAttributeWrapperEnd(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.DoctypeAttributeValue) {
+	        return handleAttributeValue(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	doctypeAttribute.construct = construct;
+	return doctypeAttribute;
+}
+
+var doctypeAttributes$1 = {};
+
+var hasRequiredDoctypeAttributes$1;
+
+function requireDoctypeAttributes$1 () {
+	if (hasRequiredDoctypeAttributes$1) return doctypeAttributes$1;
+	hasRequiredDoctypeAttributes$1 = 1;
+	Object.defineProperty(doctypeAttributes$1, "__esModule", { value: true });
+	doctypeAttributes$1.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTE_START_TOKENS = [
+	    constants_1.TokenTypes.DoctypeAttributeWrapperStart,
+	    constants_1.TokenTypes.DoctypeAttributeValue,
+	];
+	function handleDoctypeClose(state) {
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function handleAttribute(state, token) {
+	    (0, utils_1.initAttributesIfNone)(state.currentNode);
+	    // new empty attribute
+	    state.currentNode.attributes.push({
+	        type: constants_1.NodeTypes.DoctypeAttribute,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	    });
+	    state.currentContext = {
+	        type: constants_1.ConstructTreeContextTypes.DoctypeAttribute,
+	        parentRef: state.currentContext,
+	    };
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.DoctypeClose) {
+	        return handleDoctypeClose(state);
+	    }
+	    if (ATTRIBUTE_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handleAttribute(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	doctypeAttributes$1.construct = construct;
+	return doctypeAttributes$1;
+}
+
+var doctype = {};
+
+var hasRequiredDoctype;
+
+function requireDoctype () {
+	if (hasRequiredDoctype) return doctype;
+	hasRequiredDoctype = 1;
+	Object.defineProperty(doctype, "__esModule", { value: true });
+	doctype.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTES_START_TOKENS = [
+	    constants_1.TokenTypes.DoctypeAttributeWrapperStart,
+	    constants_1.TokenTypes.DoctypeAttributeValue,
+	];
+	function handleDoctypeOpen(state, token) {
+	    state.currentNode.open = (0, utils_1.createNodeFrom)(token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleDoctypeClose(state, token) {
+	    state.currentNode.close = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.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: constants_1.ConstructTreeContextTypes.DoctypeAttributes,
+	    };
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.DoctypeOpen) {
+	        return handleDoctypeOpen(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.DoctypeClose) {
+	        return handleDoctypeClose(state, token);
+	    }
+	    if (ATTRIBUTES_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handleDoctypeAttributes(state);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	doctype.construct = construct;
+	return doctype;
+}
+
+var scriptTag = {};
+
+var hasRequiredScriptTag;
+
+function requireScriptTag () {
+	if (hasRequiredScriptTag) return scriptTag;
+	hasRequiredScriptTag = 1;
+	Object.defineProperty(scriptTag, "__esModule", { value: true });
+	scriptTag.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTE_START_TOKENS = [
+	    constants_1.TokenTypes.AttributeKey,
+	    constants_1.TokenTypes.AttributeAssignment,
+	];
+	function handleOpenScriptTagStart(state, token) {
+	    state.currentNode.openStart = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeStartScript(state) {
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Attributes,
+	    };
+	    return state;
+	}
+	function handleOpenScriptTagEnd(state, token) {
+	    state.currentNode.openEnd = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleScriptContent(state, token) {
+	    state.currentNode.value = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleCloseScriptTag(state, token) {
+	    state.currentNode.close = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.currentNode = state.currentNode.parentRef;
+	    state.currentContext = state.currentContext.parentRef;
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.OpenScriptTagStart) {
+	        return handleOpenScriptTagStart(state, token);
+	    }
+	    if (ATTRIBUTE_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handleAttributeStartScript(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.OpenScriptTagEnd) {
+	        return handleOpenScriptTagEnd(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.ScriptTagContent) {
+	        return handleScriptContent(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CloseScriptTag) {
+	        return handleCloseScriptTag(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	scriptTag.construct = construct;
+	return scriptTag;
+}
+
+var styleTag = {};
+
+var hasRequiredStyleTag;
+
+function requireStyleTag () {
+	if (hasRequiredStyleTag) return styleTag;
+	hasRequiredStyleTag = 1;
+	Object.defineProperty(styleTag, "__esModule", { value: true });
+	styleTag.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTE_START_TOKENS = [
+	    constants_1.TokenTypes.AttributeKey,
+	    constants_1.TokenTypes.AttributeAssignment,
+	];
+	function handleOpenStyleTagStart(state, token) {
+	    state.currentNode.openStart = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleAttributeStartStyle(state) {
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Attributes,
+	    };
+	    return state;
+	}
+	function handleOpenStyleTagEnd(state, token) {
+	    state.currentNode.openEnd = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleStyleContent(state, token) {
+	    state.currentNode.value = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleCloseStyleTag(state, token) {
+	    state.currentNode.close = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.currentNode = state.currentNode.parentRef;
+	    state.currentContext = state.currentContext.parentRef;
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.OpenStyleTagStart) {
+	        return handleOpenStyleTagStart(state, token);
+	    }
+	    if (ATTRIBUTE_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handleAttributeStartStyle(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.OpenStyleTagEnd) {
+	        return handleOpenStyleTagEnd(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.StyleTagContent) {
+	        return handleStyleContent(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CloseStyleTag) {
+	        return handleCloseStyleTag(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	styleTag.construct = construct;
+	return styleTag;
+}
+
+var tagContent = {};
+
+var hasRequiredTagContent;
+
+function requireTagContent () {
+	if (hasRequiredTagContent) return tagContent;
+	hasRequiredTagContent = 1;
+	Object.defineProperty(tagContent, "__esModule", { value: true });
+	tagContent.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function handleOpenTagStart(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const tagNode = {
+	        type: constants_1.NodeTypes.Tag,
+	        parentRef: state.currentNode,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	        attributes: [],
+	        children: [],
+	    };
+	    state.currentNode.children.push(tagNode);
+	    state.currentNode = tagNode;
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Tag,
+	    };
+	    return state;
+	}
+	function handleCloseTag(state, token) {
+	    const closeTagName = (0, utils_1.parseCloseTagName)(token.value);
+	    if (closeTagName !== state.currentNode.name) {
+	        state.caretPosition++;
+	        return state;
+	    }
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function handleCommentOpen(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const commentNode = {
+	        type: constants_1.NodeTypes.Comment,
+	        parentRef: state.currentNode,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	    };
+	    state.currentNode.children.push(commentNode);
+	    // @ts-ignore
+	    state.currentNode = commentNode;
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Comment,
+	    };
+	    return state;
+	}
+	function handleDoctypeOpen(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const doctypeNode = {
+	        type: constants_1.NodeTypes.Doctype,
+	        parentRef: state.currentNode,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	        attributes: [],
+	    };
+	    state.currentNode.children.push(doctypeNode);
+	    // @ts-ignore
+	    state.currentNode = doctypeNode;
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Doctype,
+	    };
+	    return state;
+	}
+	function handleText(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const textNode = (0, utils_1.createNodeFrom)(token);
+	    state.currentNode.children.push(textNode);
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleOpenScriptTagStart(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const scriptNode = {
+	        type: constants_1.NodeTypes.ScriptTag,
+	        parentRef: state.currentNode,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	        attributes: [],
+	    };
+	    state.currentNode.children.push(scriptNode);
+	    // @ts-ignore
+	    state.currentNode = scriptNode;
+	    state.currentContext = {
+	        type: constants_1.ConstructTreeContextTypes.ScriptTag,
+	        parentRef: state.currentContext,
+	    };
+	    return state;
+	}
+	function handleOpenStyleTagStart(state, token) {
+	    (0, utils_1.initChildrenIfNone)(state.currentNode);
+	    const styleNode = {
+	        type: constants_1.NodeTypes.StyleTag,
+	        parentRef: state.currentNode,
+	        range: (0, utils_1.cloneRange)(token.range),
+	        loc: (0, utils_1.cloneLocation)(token.loc),
+	        attributes: [],
+	    };
+	    state.currentNode.children.push(styleNode);
+	    // @ts-ignore
+	    state.currentNode = styleNode;
+	    state.currentContext = {
+	        type: constants_1.ConstructTreeContextTypes.StyleTag,
+	        parentRef: state.currentContext,
+	    };
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.OpenScriptTagStart) {
+	        return handleOpenScriptTagStart(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.OpenStyleTagStart) {
+	        return handleOpenStyleTagStart(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.OpenTagStart) {
+	        return handleOpenTagStart(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.Text) {
+	        return handleText(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CloseTag) {
+	        return handleCloseTag(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CommentOpen) {
+	        return handleCommentOpen(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.DoctypeOpen) {
+	        return handleDoctypeOpen(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	tagContent.construct = construct;
+	return tagContent;
+}
+
+var tagName = {};
+
+var hasRequiredTagName;
+
+function requireTagName () {
+	if (hasRequiredTagName) return tagName;
+	hasRequiredTagName = 1;
+	Object.defineProperty(tagName, "__esModule", { value: true });
+	tagName.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function handleTagOpenStart(state, token) {
+	    state.currentNode.name = (0, utils_1.parseOpenTagName)(token.value);
+	    state.currentContext = state.currentContext.parentRef;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.OpenTagStart) {
+	        handleTagOpenStart(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	tagName.construct = construct;
+	return tagName;
+}
+
+var tag = {};
+
+var hasRequiredTag;
+
+function requireTag () {
+	if (hasRequiredTag) return tag;
+	hasRequiredTag = 1;
+	Object.defineProperty(tag, "__esModule", { value: true });
+	tag.construct = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const ATTRIBUTE_START_TOKENS = [
+	    constants_1.TokenTypes.AttributeKey,
+	    constants_1.TokenTypes.AttributeAssignment,
+	];
+	const SELF_CLOSING_TAGS = [
+	    "area",
+	    "base",
+	    "br",
+	    "col",
+	    "embed",
+	    "hr",
+	    "img",
+	    "input",
+	    "keygen",
+	    "link",
+	    "meta",
+	    "param",
+	    "source",
+	    "track",
+	    "wbr",
+	];
+	function handleOpenTagStart(state, token) {
+	    state.currentNode.openStart = (0, utils_1.createNodeFrom)(token);
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.TagName,
+	    };
+	    return state;
+	}
+	function handleAttributeStart(state) {
+	    state.currentContext = {
+	        parentRef: state.currentContext,
+	        type: constants_1.ConstructTreeContextTypes.Attributes,
+	    };
+	    return state;
+	}
+	function handleOpenTagEnd(state, token) {
+	    const tagName = state.currentNode.name;
+	    state.currentNode.openEnd = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    if (SELF_CLOSING_TAGS.indexOf(tagName) !== -1 ||
+	        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: constants_1.ConstructTreeContextTypes.TagContent,
+	    };
+	    state.caretPosition++;
+	    return state;
+	}
+	function handleCloseTag(state, token) {
+	    state.currentNode.close = (0, utils_1.createNodeFrom)(token);
+	    (0, utils_1.updateNodeEnd)(state.currentNode, token);
+	    state.currentNode = state.currentNode.parentRef;
+	    state.currentContext = state.currentContext.parentRef;
+	    state.caretPosition++;
+	    return state;
+	}
+	function construct(token, state) {
+	    if (token.type === constants_1.TokenTypes.OpenTagStart) {
+	        return handleOpenTagStart(state, token);
+	    }
+	    if (ATTRIBUTE_START_TOKENS.indexOf(token.type) !== -1) {
+	        return handleAttributeStart(state);
+	    }
+	    if (token.type === constants_1.TokenTypes.OpenTagEnd) {
+	        return handleOpenTagEnd(state, token);
+	    }
+	    if (token.type === constants_1.TokenTypes.CloseTag) {
+	        return handleCloseTag(state, token);
+	    }
+	    state.caretPosition++;
+	    return state;
+	}
+	tag.construct = construct;
+	return tag;
+}
+
+var hasRequiredHandlers$1;
+
+function requireHandlers$1 () {
+	if (hasRequiredHandlers$1) return handlers$1;
+	hasRequiredHandlers$1 = 1;
+	var __createBinding = (handlers$1 && handlers$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (handlers$1 && handlers$1.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (handlers$1 && handlers$1.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(handlers$1, "__esModule", { value: true });
+	handlers$1.tag = handlers$1.tagName = handlers$1.tagContent = handlers$1.styleTag = handlers$1.scriptTag = handlers$1.doctype = handlers$1.doctypeAttributes = handlers$1.doctypeAttribute = handlers$1.comment = handlers$1.attribute = handlers$1.attributes = handlers$1.attributeValue = void 0;
+	handlers$1.attributeValue = __importStar(requireAttributeValue$1());
+	handlers$1.attributes = __importStar(requireAttributes$1());
+	handlers$1.attribute = __importStar(requireAttribute());
+	handlers$1.comment = __importStar(requireComment());
+	handlers$1.doctypeAttribute = __importStar(requireDoctypeAttribute());
+	handlers$1.doctypeAttributes = __importStar(requireDoctypeAttributes$1());
+	handlers$1.doctype = __importStar(requireDoctype());
+	handlers$1.scriptTag = __importStar(requireScriptTag());
+	handlers$1.styleTag = __importStar(requireStyleTag());
+	handlers$1.tagContent = __importStar(requireTagContent());
+	handlers$1.tagName = __importStar(requireTagName());
+	handlers$1.tag = __importStar(requireTag());
+	return handlers$1;
+}
+
+var hasRequiredConstructTree;
+
+function requireConstructTree () {
+	if (hasRequiredConstructTree) return constructTree;
+	hasRequiredConstructTree = 1;
+	Object.defineProperty(constructTree, "__esModule", { value: true });
+	constructTree.constructTree = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const clone_location_1 = requireCloneLocation();
+	const handlers_1 = requireHandlers$1();
+	const contextHandlers = {
+	    [constants_1.ConstructTreeContextTypes.TagContent]: handlers_1.tagContent,
+	    [constants_1.ConstructTreeContextTypes.Tag]: handlers_1.tag,
+	    [constants_1.ConstructTreeContextTypes.TagName]: handlers_1.tagName,
+	    [constants_1.ConstructTreeContextTypes.Attribute]: handlers_1.attribute,
+	    [constants_1.ConstructTreeContextTypes.Attributes]: handlers_1.attributes,
+	    [constants_1.ConstructTreeContextTypes.AttributeValue]: handlers_1.attributeValue,
+	    [constants_1.ConstructTreeContextTypes.Comment]: handlers_1.comment,
+	    [constants_1.ConstructTreeContextTypes.Doctype]: handlers_1.doctype,
+	    [constants_1.ConstructTreeContextTypes.DoctypeAttributes]: handlers_1.doctypeAttributes,
+	    [constants_1.ConstructTreeContextTypes.DoctypeAttribute]: handlers_1.doctypeAttribute,
+	    [constants_1.ConstructTreeContextTypes.ScriptTag]: handlers_1.scriptTag,
+	    [constants_1.ConstructTreeContextTypes.StyleTag]: handlers_1.styleTag,
+	};
+	const EMPTY_RANGE = [0, 0];
+	const EMPTY_LOC = {
+	    start: {
+	        line: 1,
+	        column: 0,
+	    },
+	    end: {
+	        line: 1,
+	        column: 0,
+	    },
+	};
+	function constructTree$1(tokens, existingState) {
+	    let state = existingState;
+	    if (existingState === undefined) {
+	        const rootContext = {
+	            type: constants_1.ConstructTreeContextTypes.TagContent,
+	            parentRef: undefined,
+	            content: [],
+	        };
+	        const lastToken = (0, utils_1.last)(tokens);
+	        const firstToken = (0, utils_1.first)(tokens);
+	        const range = lastToken ? [0, lastToken.range[1]] : EMPTY_RANGE;
+	        const loc = lastToken
+	            ? {
+	                start: (0, clone_location_1.cloneLocation)(firstToken.loc).start,
+	                end: (0, clone_location_1.cloneLocation)(lastToken.loc).end,
+	            }
+	            : EMPTY_LOC;
+	        loc.start.line = 1;
+	        const rootNode = {
+	            type: constants_1.NodeTypes.Document,
+	            range,
+	            children: [],
+	            loc,
+	        };
+	        state = {
+	            caretPosition: 0,
+	            currentContext: rootContext,
+	            currentNode: rootNode,
+	            rootNode,
+	        };
+	    }
+	    const positionOffset = state.caretPosition;
+	    processTokens(tokens, state, positionOffset);
+	    return { state, ast: state.rootNode };
+	}
+	constructTree.constructTree = constructTree$1;
+	function processTokens(tokens, state, positionOffset) {
+	    let tokenIndex = state.caretPosition - positionOffset;
+	    while (tokenIndex < tokens.length) {
+	        const token = tokens[tokenIndex];
+	        const handler = contextHandlers[state.currentContext.type].construct;
+	        state = handler(token, state);
+	        tokenIndex = state.caretPosition - positionOffset;
+	    }
+	    return state;
+	}
+	return constructTree;
+}
+
+var hasRequiredTreeConstructor;
+
+function requireTreeConstructor () {
+	if (hasRequiredTreeConstructor) return treeConstructor;
+	hasRequiredTreeConstructor = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.constructTree = void 0;
+		var construct_tree_1 = requireConstructTree();
+		Object.defineProperty(exports, "constructTree", { enumerable: true, get: function () { return construct_tree_1.constructTree; } }); 
+	} (treeConstructor));
+	return treeConstructor;
+}
+
+var tokenizer = {};
+
+var tokenize = {};
+
+var handlers = {};
+
+var attributeKey = {};
+
+var hasRequiredAttributeKey;
+
+function requireAttributeKey () {
+	if (hasRequiredAttributeKey) return attributeKey;
+	hasRequiredAttributeKey = 1;
+	Object.defineProperty(attributeKey, "__esModule", { value: true });
+	attributeKey.parse = void 0;
+	const constants_1 = requireConstants();
+	const token_types_1 = requireTokenTypes();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (isKeyBreak(chars)) {
+	        return parseKeyEnd(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	attributeKey.parse = parse;
+	function isKeyBreak(chars) {
+	    return chars === "=" || chars === "/" || chars === ">" || (0, utils_1.isWhitespace)(chars);
+	}
+	function parseKeyEnd(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    tokens.push({
+	        type: token_types_1.TokenTypes.AttributeKey,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Attributes;
+	}
+	return attributeKey;
+}
+
+var attributeValueBare = {};
+
+var hasRequiredAttributeValueBare;
+
+function requireAttributeValueBare () {
+	if (hasRequiredAttributeValueBare) return attributeValueBare;
+	hasRequiredAttributeValueBare = 1;
+	Object.defineProperty(attributeValueBare, "__esModule", { value: true });
+	attributeValueBare.parse = attributeValueBare.parseValueEnd = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parseValueEnd(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    tokens.push({
+	        type: constants_1.TokenTypes.AttributeValue,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Attributes;
+	}
+	attributeValueBare.parseValueEnd = parseValueEnd;
+	function parse(chars, state, tokens) {
+	    if ((0, utils_1.isWhitespace)(chars) || chars === ">" || chars === "/") {
+	        return parseValueEnd(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	attributeValueBare.parse = parse;
+	return attributeValueBare;
+}
+
+var attributeValueWrapped = {};
+
+var hasRequiredAttributeValueWrapped;
+
+function requireAttributeValueWrapped () {
+	if (hasRequiredAttributeValueWrapped) return attributeValueWrapped;
+	hasRequiredAttributeValueWrapped = 1;
+	Object.defineProperty(attributeValueWrapped, "__esModule", { value: true });
+	attributeValueWrapped.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    var _a;
+	    const wrapperChar = (_a = state.contextParams[constants_1.TokenizerContextTypes.AttributeValueWrapped]) === null || _a === void 0 ? void 0 : _a.wrapper;
+	    if (chars === wrapperChar) {
+	        return parseWrapper(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	attributeValueWrapped.parse = parse;
+	function parseWrapper(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    const endWrapperPosition = position.range[1];
+	    tokens.push({
+	        type: constants_1.TokenTypes.AttributeValue,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    const range = [endWrapperPosition, endWrapperPosition + 1];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.AttributeValueWrapperEnd,
+	        value: state.decisionBuffer,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Attributes;
+	    state.caretPosition++;
+	    state.contextParams[constants_1.TokenizerContextTypes.AttributeValueWrapped] = undefined;
+	}
+	return attributeValueWrapped;
+}
+
+var attributeValue = {};
+
+var hasRequiredAttributeValue;
+
+function requireAttributeValue () {
+	if (hasRequiredAttributeValue) return attributeValue;
+	hasRequiredAttributeValue = 1;
+	Object.defineProperty(attributeValue, "__esModule", { value: true });
+	attributeValue.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (chars === '"' || chars === "'") {
+	        return parseWrapper(state, tokens);
+	    }
+	    if (chars === ">" || chars === "/") {
+	        return parseTagEnd(state);
+	    }
+	    if (!(0, utils_1.isWhitespace)(chars)) {
+	        return parseBare(state);
+	    }
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	attributeValue.parse = parse;
+	function parseWrapper(state, tokens) {
+	    const wrapper = state.decisionBuffer;
+	    const range = [state.caretPosition, state.caretPosition + 1];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.AttributeValueWrapperStart,
+	        value: wrapper,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.AttributeValueWrapped;
+	    state.contextParams[constants_1.TokenizerContextTypes.AttributeValueWrapped] = {
+	        wrapper,
+	    };
+	    state.caretPosition++;
+	}
+	function parseBare(state) {
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.AttributeValueBare;
+	    state.caretPosition++;
+	}
+	function parseTagEnd(state) {
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Attributes;
+	}
+	return attributeValue;
+}
+
+var attributes = {};
+
+var hasRequiredAttributes;
+
+function requireAttributes () {
+	if (hasRequiredAttributes) return attributes;
+	hasRequiredAttributes = 1;
+	Object.defineProperty(attributes, "__esModule", { value: true });
+	attributes.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (chars === ">" || chars === "/") {
+	        return parseTagEnd(state);
+	    }
+	    if (chars === "=") {
+	        return parseEqual(state, tokens);
+	    }
+	    if (!(0, utils_1.isWhitespace)(chars)) {
+	        return parseNoneWhitespace(state);
+	    }
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	attributes.parse = parse;
+	function parseTagEnd(state) {
+	    var _a;
+	    const tagName = (_a = state.contextParams[constants_1.TokenizerContextTypes.Attributes]) === null || _a === void 0 ? void 0 : _a.tagName;
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.OpenTagEnd;
+	    state.contextParams[constants_1.TokenizerContextTypes.OpenTagEnd] = { tagName: tagName };
+	    state.contextParams[constants_1.TokenizerContextTypes.Attributes] = undefined;
+	}
+	function parseNoneWhitespace(state) {
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.AttributeKey;
+	    state.caretPosition++;
+	}
+	function parseEqual(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: true });
+	    tokens.push({
+	        type: constants_1.TokenTypes.AttributeAssignment,
+	        value: state.decisionBuffer,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.AttributeValue;
+	    state.caretPosition++;
+	}
+	return attributes;
+}
+
+var closeTag = {};
+
+var hasRequiredCloseTag;
+
+function requireCloseTag () {
+	if (hasRequiredCloseTag) return closeTag;
+	hasRequiredCloseTag = 1;
+	Object.defineProperty(closeTag, "__esModule", { value: true });
+	closeTag.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (chars === ">") {
+	        return parseClosingCornerBrace(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	closeTag.parse = parse;
+	function parseClosingCornerBrace(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: true });
+	    tokens.push({
+	        type: constants_1.TokenTypes.CloseTag,
+	        value: state.accumulatedContent + state.decisionBuffer,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Data;
+	    state.caretPosition++;
+	}
+	return closeTag;
+}
+
+var commentContent = {};
+
+var hasRequiredCommentContent;
+
+function requireCommentContent () {
+	if (hasRequiredCommentContent) return commentContent;
+	hasRequiredCommentContent = 1;
+	Object.defineProperty(commentContent, "__esModule", { value: true });
+	commentContent.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const COMMENT_END = "-->";
+	function parse(chars, state, tokens) {
+	    if (chars === "-" || chars === "--") {
+	        state.caretPosition++;
+	        return;
+	    }
+	    if (chars === COMMENT_END) {
+	        return parseCommentClose(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	commentContent.parse = parse;
+	function parseCommentClose(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    const endRange = [
+	        position.range[1],
+	        position.range[1] + COMMENT_END.length,
+	    ];
+	    const endLoc = (0, utils_1.calculateTokenLocation)(state.source, endRange);
+	    tokens.push({
+	        type: constants_1.TokenTypes.CommentContent,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    }, {
+	        type: constants_1.TokenTypes.CommentClose,
+	        value: state.decisionBuffer,
+	        range: endRange,
+	        loc: endLoc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Data;
+	    state.caretPosition++;
+	}
+	return commentContent;
+}
+
+var data = {};
+
+var hasRequiredData;
+
+function requireData () {
+	if (hasRequiredData) return data;
+	hasRequiredData = 1;
+	Object.defineProperty(data, "__esModule", { value: true });
+	data.handleContentEnd = data.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const COMMENT_START = "<!--";
+	const OPEN_TAG_START_PATTERN = /^<\w/;
+	function parse(chars, state, tokens) {
+	    if (OPEN_TAG_START_PATTERN.test(chars)) {
+	        return parseOpeningCornerBraceWithText(state, tokens);
+	    }
+	    if (chars === "</") {
+	        return parseOpeningCornerBraceWithSlash(state, tokens);
+	    }
+	    if (chars === "<" || chars === "<!" || chars === "<!-") {
+	        state.caretPosition++;
+	        return;
+	    }
+	    if (chars === COMMENT_START) {
+	        return parseCommentOpen(state, tokens);
+	    }
+	    if (isIncompleteDoctype(chars)) {
+	        state.caretPosition++;
+	        return;
+	    }
+	    if (chars.toUpperCase() === "<!DOCTYPE") {
+	        return parseDoctypeOpen(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	data.parse = parse;
+	function handleContentEnd(state, tokens) {
+	    const textContent = state.accumulatedContent + state.decisionBuffer;
+	    if (textContent.length !== 0) {
+	        const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	        tokens.push({
+	            type: constants_1.TokenTypes.Text,
+	            value: textContent,
+	            range: position.range,
+	            loc: position.loc,
+	        });
+	    }
+	}
+	data.handleContentEnd = handleContentEnd;
+	function generateTextToken(state) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    return {
+	        type: constants_1.TokenTypes.Text,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    };
+	}
+	function parseOpeningCornerBraceWithText(state, tokens) {
+	    if (state.accumulatedContent.length !== 0) {
+	        tokens.push(generateTextToken(state));
+	    }
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.OpenTagStart;
+	    state.caretPosition++;
+	}
+	function parseOpeningCornerBraceWithSlash(state, tokens) {
+	    if (state.accumulatedContent.length !== 0) {
+	        tokens.push(generateTextToken(state));
+	    }
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.CloseTag;
+	    state.caretPosition++;
+	}
+	function isIncompleteDoctype(chars) {
+	    const charsUpperCase = chars.toUpperCase();
+	    return (charsUpperCase === "<!" ||
+	        charsUpperCase === "<!D" ||
+	        charsUpperCase === "<!DO" ||
+	        charsUpperCase === "<!DOC" ||
+	        charsUpperCase === "<!DOCT" ||
+	        charsUpperCase === "<!DOCTY" ||
+	        charsUpperCase === "<!DOCTYP");
+	}
+	function parseCommentOpen(state, tokens) {
+	    if (state.accumulatedContent.length !== 0) {
+	        tokens.push(generateTextToken(state));
+	    }
+	    const range = [
+	        state.caretPosition - (COMMENT_START.length - 1),
+	        state.caretPosition + 1,
+	    ];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.CommentOpen,
+	        value: state.decisionBuffer,
+	        range: range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.CommentContent;
+	    state.caretPosition++;
+	}
+	function parseDoctypeOpen(state, tokens) {
+	    if (state.accumulatedContent.length !== 0) {
+	        tokens.push(generateTextToken(state));
+	    }
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeOpen;
+	    state.caretPosition++;
+	}
+	return data;
+}
+
+var doctypeAttributeBare = {};
+
+var hasRequiredDoctypeAttributeBare;
+
+function requireDoctypeAttributeBare () {
+	if (hasRequiredDoctypeAttributeBare) return doctypeAttributeBare;
+	hasRequiredDoctypeAttributeBare = 1;
+	Object.defineProperty(doctypeAttributeBare, "__esModule", { value: true });
+	doctypeAttributeBare.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if ((0, utils_1.isWhitespace)(chars) || chars === ">") {
+	        return parseAttributeEnd(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	doctypeAttributeBare.parse = parse;
+	function parseAttributeEnd(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    tokens.push({
+	        type: constants_1.TokenTypes.DoctypeAttributeValue,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeAttributes;
+	}
+	return doctypeAttributeBare;
+}
+
+var doctypeAttributeWrapped = {};
+
+var hasRequiredDoctypeAttributeWrapped;
+
+function requireDoctypeAttributeWrapped () {
+	if (hasRequiredDoctypeAttributeWrapped) return doctypeAttributeWrapped;
+	hasRequiredDoctypeAttributeWrapped = 1;
+	Object.defineProperty(doctypeAttributeWrapped, "__esModule", { value: true });
+	doctypeAttributeWrapped.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    var _a;
+	    const wrapperChar = (_a = state.contextParams[constants_1.TokenizerContextTypes.DoctypeAttributeWrapped]) === null || _a === void 0 ? void 0 : _a.wrapper;
+	    if (chars === wrapperChar) {
+	        return parseWrapper(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	doctypeAttributeWrapped.parse = parse;
+	function parseWrapper(state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    const endWrapperPosition = position.range[1];
+	    tokens.push({
+	        type: constants_1.TokenTypes.DoctypeAttributeValue,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    const range = [endWrapperPosition, endWrapperPosition + 1];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.DoctypeAttributeWrapperEnd,
+	        value: state.decisionBuffer,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeAttributes;
+	    state.caretPosition++;
+	    state.contextParams[constants_1.TokenizerContextTypes.DoctypeAttributeWrapped] =
+	        undefined;
+	}
+	return doctypeAttributeWrapped;
+}
+
+var doctypeAttributes = {};
+
+var hasRequiredDoctypeAttributes;
+
+function requireDoctypeAttributes () {
+	if (hasRequiredDoctypeAttributes) return doctypeAttributes;
+	hasRequiredDoctypeAttributes = 1;
+	Object.defineProperty(doctypeAttributes, "__esModule", { value: true });
+	doctypeAttributes.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (chars === '"' || chars === "'") {
+	        return parseWrapper(state, tokens);
+	    }
+	    if (chars === ">") {
+	        return parseClosingCornerBrace(state);
+	    }
+	    if (!(0, utils_1.isWhitespace)(chars)) {
+	        return parseBare(state);
+	    }
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	doctypeAttributes.parse = parse;
+	function parseWrapper(state, tokens) {
+	    const wrapper = state.decisionBuffer;
+	    const range = [
+	        state.caretPosition,
+	        state.caretPosition + wrapper.length,
+	    ];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.DoctypeAttributeWrapperStart,
+	        value: wrapper,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeAttributeWrapped;
+	    state.contextParams[constants_1.TokenizerContextTypes.DoctypeAttributeWrapped] = {
+	        wrapper,
+	    };
+	    state.caretPosition++;
+	}
+	function parseBare(state) {
+	    state.accumulatedContent = state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeAttributeBare;
+	    state.caretPosition++;
+	}
+	function parseClosingCornerBrace(state) {
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeClose;
+	}
+	return doctypeAttributes;
+}
+
+var doctypeEnd = {};
+
+var hasRequiredDoctypeEnd;
+
+function requireDoctypeEnd () {
+	if (hasRequiredDoctypeEnd) return doctypeEnd;
+	hasRequiredDoctypeEnd = 1;
+	Object.defineProperty(doctypeEnd, "__esModule", { value: true });
+	doctypeEnd.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: true });
+	    tokens.push({
+	        type: constants_1.TokenTypes.DoctypeClose,
+	        value: state.decisionBuffer,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Data;
+	    state.caretPosition++;
+	}
+	doctypeEnd.parse = parse;
+	return doctypeEnd;
+}
+
+var doctypeStart = {};
+
+var hasRequiredDoctypeStart;
+
+function requireDoctypeStart () {
+	if (hasRequiredDoctypeStart) return doctypeStart;
+	hasRequiredDoctypeStart = 1;
+	Object.defineProperty(doctypeStart, "__esModule", { value: true });
+	doctypeStart.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if ((0, utils_1.isWhitespace)(chars)) {
+	        return parseWhitespace(state, tokens);
+	    }
+	    if (chars === ">") {
+	        return parseClosingCornerBrace(state, tokens);
+	    }
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	doctypeStart.parse = parse;
+	function generateDoctypeOpenToken(state) {
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    return {
+	        type: constants_1.TokenTypes.DoctypeOpen,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    };
+	}
+	function parseWhitespace(state, tokens) {
+	    tokens.push(generateDoctypeOpenToken(state));
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeAttributes;
+	}
+	function parseClosingCornerBrace(state, tokens) {
+	    tokens.push(generateDoctypeOpenToken(state));
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.DoctypeClose;
+	}
+	return doctypeStart;
+}
+
+var openTagEnd = {};
+
+var hasRequiredOpenTagEnd;
+
+function requireOpenTagEnd () {
+	if (hasRequiredOpenTagEnd) return openTagEnd;
+	hasRequiredOpenTagEnd = 1;
+	Object.defineProperty(openTagEnd, "__esModule", { value: true });
+	openTagEnd.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const tokensMap = {
+	    script: constants_1.TokenTypes.OpenScriptTagEnd,
+	    style: constants_1.TokenTypes.OpenStyleTagEnd,
+	    default: constants_1.TokenTypes.OpenTagEnd,
+	};
+	const contextsMap = {
+	    script: constants_1.TokenizerContextTypes.ScriptContent,
+	    style: constants_1.TokenizerContextTypes.StyleContent,
+	    default: constants_1.TokenizerContextTypes.Data,
+	};
+	function parse(chars, state, tokens) {
+	    if (chars === ">") {
+	        return parseClosingCornerBrace(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	openTagEnd.parse = parse;
+	function parseClosingCornerBrace(state, tokens) {
+	    var _a;
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: true });
+	    const tagName = (_a = state.contextParams[constants_1.TokenizerContextTypes.OpenTagEnd]) === null || _a === void 0 ? void 0 : _a.tagName;
+	    tokens.push({
+	        type: tokensMap[tagName] || tokensMap.default,
+	        value: state.accumulatedContent + state.decisionBuffer,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext =
+	        contextsMap[tagName || "default"] || contextsMap["default"];
+	    state.caretPosition++;
+	    state.contextParams[constants_1.TokenizerContextTypes.OpenTagEnd] = undefined;
+	}
+	return openTagEnd;
+}
+
+var openTagStart = {};
+
+var hasRequiredOpenTagStart;
+
+function requireOpenTagStart () {
+	if (hasRequiredOpenTagStart) return openTagStart;
+	hasRequiredOpenTagStart = 1;
+	Object.defineProperty(openTagStart, "__esModule", { value: true });
+	openTagStart.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const tokensMap = {
+	    script: constants_1.TokenTypes.OpenScriptTagStart,
+	    style: constants_1.TokenTypes.OpenStyleTagStart,
+	    default: constants_1.TokenTypes.OpenTagStart,
+	};
+	function parse(chars, state, tokens) {
+	    if (chars === ">" || chars === "/") {
+	        return parseTagEnd(state, tokens);
+	    }
+	    if ((0, utils_1.isWhitespace)(chars)) {
+	        return parseWhitespace(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	openTagStart.parse = parse;
+	function parseWhitespace(state, tokens) {
+	    const tagName = (0, utils_1.parseOpenTagName)(state.accumulatedContent);
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    tokens.push({
+	        type: tokensMap[tagName] || tokensMap.default,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Attributes;
+	    state.contextParams[constants_1.TokenizerContextTypes.Attributes] = { tagName };
+	    state.caretPosition++;
+	}
+	function parseTagEnd(state, tokens) {
+	    const tagName = (0, utils_1.parseOpenTagName)(state.accumulatedContent);
+	    const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	    tokens.push({
+	        type: tokensMap[tagName] || tokensMap.default,
+	        value: state.accumulatedContent,
+	        range: position.range,
+	        loc: position.loc,
+	    });
+	    state.decisionBuffer = "";
+	    state.accumulatedContent = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.OpenTagEnd;
+	    state.contextParams[constants_1.TokenizerContextTypes.OpenTagEnd] = { tagName };
+	}
+	return openTagStart;
+}
+
+var scriptTagContent = {};
+
+var hasRequiredScriptTagContent;
+
+function requireScriptTagContent () {
+	if (hasRequiredScriptTagContent) return scriptTagContent;
+	hasRequiredScriptTagContent = 1;
+	Object.defineProperty(scriptTagContent, "__esModule", { value: true });
+	scriptTagContent.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	function parse(chars, state, tokens) {
+	    if (chars === "<" ||
+	        chars === "</" ||
+	        constants_1.INCOMPLETE_CLOSING_TAG_PATTERN.test(chars)) {
+	        state.caretPosition++;
+	        return;
+	    }
+	    if (constants_1.CLOSING_SCRIPT_TAG_PATTERN.test(chars)) {
+	        return parseClosingScriptTag(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	scriptTagContent.parse = parse;
+	function parseClosingScriptTag(state, tokens) {
+	    if (state.accumulatedContent !== "") {
+	        const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	        tokens.push({
+	            type: constants_1.TokenTypes.ScriptTagContent,
+	            value: state.accumulatedContent,
+	            range: position.range,
+	            loc: position.loc,
+	        });
+	    }
+	    const range = [
+	        state.caretPosition - (state.decisionBuffer.length - 1),
+	        state.caretPosition + 1,
+	    ];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.CloseScriptTag,
+	        value: state.decisionBuffer,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Data;
+	    state.caretPosition++;
+	}
+	return scriptTagContent;
+}
+
+var styleTagContent = {};
+
+var hasRequiredStyleTagContent;
+
+function requireStyleTagContent () {
+	if (hasRequiredStyleTagContent) return styleTagContent;
+	hasRequiredStyleTagContent = 1;
+	Object.defineProperty(styleTagContent, "__esModule", { value: true });
+	styleTagContent.parse = void 0;
+	const constants_1 = requireConstants();
+	const utils_1 = requireUtils();
+	const CLOSING_STYLE_TAG_PATTERN = /<\/style\s*>/i;
+	function parse(chars, state, tokens) {
+	    if (chars === "<" ||
+	        chars === "</" ||
+	        constants_1.INCOMPLETE_CLOSING_TAG_PATTERN.test(chars)) {
+	        state.caretPosition++;
+	        return;
+	    }
+	    if (CLOSING_STYLE_TAG_PATTERN.test(chars)) {
+	        return parseClosingStyleTag(state, tokens);
+	    }
+	    state.accumulatedContent += state.decisionBuffer;
+	    state.decisionBuffer = "";
+	    state.caretPosition++;
+	}
+	styleTagContent.parse = parse;
+	function parseClosingStyleTag(state, tokens) {
+	    if (state.accumulatedContent !== "") {
+	        const position = (0, utils_1.calculateTokenPosition)(state, { keepBuffer: false });
+	        tokens.push({
+	            type: constants_1.TokenTypes.StyleTagContent,
+	            value: state.accumulatedContent,
+	            range: position.range,
+	            loc: position.loc,
+	        });
+	    }
+	    const range = [
+	        state.caretPosition - (state.decisionBuffer.length - 1),
+	        state.caretPosition + 1,
+	    ];
+	    const loc = (0, utils_1.calculateTokenLocation)(state.source, range);
+	    tokens.push({
+	        type: constants_1.TokenTypes.CloseStyleTag,
+	        value: state.decisionBuffer,
+	        range,
+	        loc,
+	    });
+	    state.accumulatedContent = "";
+	    state.decisionBuffer = "";
+	    state.currentContext = constants_1.TokenizerContextTypes.Data;
+	    state.caretPosition++;
+	}
+	return styleTagContent;
+}
+
+var hasRequiredHandlers;
+
+function requireHandlers () {
+	if (hasRequiredHandlers) return handlers;
+	hasRequiredHandlers = 1;
+	var __createBinding = (handlers && handlers.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (handlers && handlers.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (handlers && handlers.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(handlers, "__esModule", { value: true });
+	handlers.noop = handlers.styleTagContent = handlers.scriptTagContent = handlers.openTagStart = handlers.openTagEnd = handlers.DoctypeOpen = handlers.DoctypeClose = handlers.doctypeAttributes = handlers.doctypeAttributeWrapped = handlers.doctypeAttributeBare = handlers.data = handlers.commentContent = handlers.closeTag = handlers.attributes = handlers.attributeValue = handlers.attributeValueWrapped = handlers.attributeValueBare = handlers.attributeKey = void 0;
+	handlers.attributeKey = __importStar(requireAttributeKey());
+	handlers.attributeValueBare = __importStar(requireAttributeValueBare());
+	handlers.attributeValueWrapped = __importStar(requireAttributeValueWrapped());
+	handlers.attributeValue = __importStar(requireAttributeValue());
+	handlers.attributes = __importStar(requireAttributes());
+	handlers.closeTag = __importStar(requireCloseTag());
+	handlers.commentContent = __importStar(requireCommentContent());
+	handlers.data = __importStar(requireData());
+	handlers.doctypeAttributeBare = __importStar(requireDoctypeAttributeBare());
+	handlers.doctypeAttributeWrapped = __importStar(requireDoctypeAttributeWrapped());
+	handlers.doctypeAttributes = __importStar(requireDoctypeAttributes());
+	handlers.DoctypeClose = __importStar(requireDoctypeEnd());
+	handlers.DoctypeOpen = __importStar(requireDoctypeStart());
+	handlers.openTagEnd = __importStar(requireOpenTagEnd());
+	handlers.openTagStart = __importStar(requireOpenTagStart());
+	handlers.scriptTagContent = __importStar(requireScriptTagContent());
+	handlers.styleTagContent = __importStar(requireStyleTagContent());
+	handlers.noop = {
+	    parse: () => void 0,
+	};
+	return handlers;
+}
+
+var hasRequiredTokenize;
+
+function requireTokenize () {
+	if (hasRequiredTokenize) return tokenize;
+	hasRequiredTokenize = 1;
+	Object.defineProperty(tokenize, "__esModule", { value: true });
+	tokenize.tokenize = void 0;
+	const constants_1 = requireConstants();
+	const handlers_1 = requireHandlers();
+	const contextHandlers = {
+	    [constants_1.TokenizerContextTypes.Data]: handlers_1.data,
+	    [constants_1.TokenizerContextTypes.OpenTagStart]: handlers_1.openTagStart,
+	    [constants_1.TokenizerContextTypes.CloseTag]: handlers_1.closeTag,
+	    [constants_1.TokenizerContextTypes.Attributes]: handlers_1.attributes,
+	    [constants_1.TokenizerContextTypes.OpenTagEnd]: handlers_1.openTagEnd,
+	    [constants_1.TokenizerContextTypes.AttributeKey]: handlers_1.attributeKey,
+	    [constants_1.TokenizerContextTypes.AttributeValue]: handlers_1.attributeValue,
+	    [constants_1.TokenizerContextTypes.AttributeValueBare]: handlers_1.attributeValueBare,
+	    [constants_1.TokenizerContextTypes.AttributeValueWrapped]: handlers_1.attributeValueWrapped,
+	    [constants_1.TokenizerContextTypes.ScriptContent]: handlers_1.scriptTagContent,
+	    [constants_1.TokenizerContextTypes.StyleContent]: handlers_1.styleTagContent,
+	    [constants_1.TokenizerContextTypes.DoctypeOpen]: handlers_1.DoctypeOpen,
+	    [constants_1.TokenizerContextTypes.DoctypeClose]: handlers_1.DoctypeClose,
+	    [constants_1.TokenizerContextTypes.DoctypeAttributes]: handlers_1.doctypeAttributes,
+	    [constants_1.TokenizerContextTypes.DoctypeAttributeWrapped]: handlers_1.doctypeAttributeWrapped,
+	    [constants_1.TokenizerContextTypes.DoctypeAttributeBare]: handlers_1.doctypeAttributeBare,
+	    [constants_1.TokenizerContextTypes.CommentContent]: handlers_1.commentContent,
+	    [constants_1.TokenizerContextTypes.CommentOpen]: handlers_1.noop,
+	    [constants_1.TokenizerContextTypes.CommentClose]: handlers_1.noop,
+	};
+	function tokenizeChars(chars, state, tokens, { isFinalChunk, positionOffset, }) {
+	    let charIndex = state.caretPosition - positionOffset;
+	    let charIndexBefore = charIndex;
+	    while (charIndex < chars.length) {
+	        const handler = contextHandlers[state.currentContext];
+	        state.decisionBuffer += chars[charIndex];
+	        if (charIndexBefore !== charIndex && chars[charIndex] === "\n") {
+	            state.linePosition++;
+	        }
+	        charIndexBefore = charIndex;
+	        handler.parse(state.decisionBuffer, state, tokens);
+	        charIndex = state.caretPosition - positionOffset;
+	    }
+	    if (isFinalChunk) {
+	        const handler = contextHandlers[state.currentContext];
+	        state.caretPosition--;
+	        if (handler.handleContentEnd !== undefined) {
+	            handler.handleContentEnd(state, tokens);
+	        }
+	    }
+	}
+	function tokenize$1(source = "", { isFinalChunk, } = {}) {
+	    isFinalChunk = isFinalChunk === undefined ? true : isFinalChunk;
+	    const state = {
+	        currentContext: constants_1.TokenizerContextTypes.Data,
+	        contextParams: {},
+	        decisionBuffer: "",
+	        accumulatedContent: "",
+	        caretPosition: 0,
+	        linePosition: 1,
+	        source,
+	    };
+	    const chars = state.decisionBuffer + source;
+	    const tokens = [];
+	    const positionOffset = state.caretPosition - state.decisionBuffer.length;
+	    tokenizeChars(chars, state, tokens, {
+	        isFinalChunk,
+	        positionOffset,
+	    });
+	    return { state, tokens };
+	}
+	tokenize.tokenize = tokenize$1;
+	return tokenize;
+}
+
+var hasRequiredTokenizer;
+
+function requireTokenizer () {
+	if (hasRequiredTokenizer) return tokenizer;
+	hasRequiredTokenizer = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.tokenize = void 0;
+		var tokenize_1 = requireTokenize();
+		Object.defineProperty(exports, "tokenize", { enumerable: true, get: function () { return tokenize_1.tokenize; } }); 
+	} (tokenizer));
+	return tokenizer;
+}
+
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse;
+	hasRequiredParse = 1;
+	Object.defineProperty(parse, "__esModule", { value: true });
+	parse.parse = void 0;
+	const tree_constructor_1 = requireTreeConstructor();
+	const tokenizer_1 = requireTokenizer();
+	const utils_1 = requireUtils();
+	function parse$1(html) {
+	    const { tokens } = (0, tokenizer_1.tokenize)(html, undefined);
+	    const { ast } = (0, tree_constructor_1.constructTree)(tokens, undefined);
+	    return {
+	        ast: (0, utils_1.clearParent)(ast),
+	        tokens,
+	    };
+	}
+	parse.parse = parse$1;
+	return parse;
+}
+
+var hasRequiredParser$1;
+
+function requireParser$1 () {
+	if (hasRequiredParser$1) return parser;
+	hasRequiredParser$1 = 1;
+	(function (exports) {
+		var __createBinding = (parser && parser.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (parser && parser.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireParse(), exports); 
+	} (parser));
+	return parser;
+}
+
+var node$1 = {};
+
+var hasRequiredNode$1;
+
+function requireNode$1 () {
+	if (hasRequiredNode$1) return node$1;
+	hasRequiredNode$1 = 1;
+	Object.defineProperty(node$1, "__esModule", { value: true });
+	return node$1;
+}
+
+var hasRequiredDist$1;
+
+function requireDist$1 () {
+	if (hasRequiredDist$1) return dist;
+	hasRequiredDist$1 = 1;
+	(function (exports) {
+		var __createBinding = (dist && dist.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (dist && dist.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.TokenTypes = exports.NodeTypes = exports.parse = void 0;
+		var parser_1 = requireParser$1();
+		Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
+		var constants_1 = requireConstants();
+		Object.defineProperty(exports, "NodeTypes", { enumerable: true, get: function () { return constants_1.NodeTypes; } });
+		Object.defineProperty(exports, "TokenTypes", { enumerable: true, get: function () { return constants_1.TokenTypes; } });
+		__exportStar(requireNode$1(), exports); 
+	} (dist));
+	return dist;
+}
+
+var visitorKeys = {};
+
+var hasRequiredVisitorKeys;
+
+function requireVisitorKeys () {
+	if (hasRequiredVisitorKeys) return visitorKeys;
+	hasRequiredVisitorKeys = 1;
+	Object.defineProperty(visitorKeys, "__esModule", { value: true });
+	visitorKeys.visitorKeys = void 0;
+	const es_html_parser_1 = requireDist$1();
+	visitorKeys.visitorKeys = {
+	    Program: ["body"],
+	    [es_html_parser_1.NodeTypes.Attribute]: ["key", "startWrapper", "endWrapper", "value"],
+	    [es_html_parser_1.NodeTypes.AttributeKey]: [],
+	    [es_html_parser_1.NodeTypes.AttributeValue]: [],
+	    [es_html_parser_1.NodeTypes.AttributeValueWrapperEnd]: [],
+	    [es_html_parser_1.NodeTypes.AttributeValueWrapperStart]: [],
+	    [es_html_parser_1.NodeTypes.CloseScriptTag]: [],
+	    [es_html_parser_1.NodeTypes.CloseStyleTag]: [],
+	    [es_html_parser_1.NodeTypes.CloseTag]: [],
+	    [es_html_parser_1.NodeTypes.Comment]: ["open", "close", "value"],
+	    [es_html_parser_1.NodeTypes.CommentContent]: [],
+	    [es_html_parser_1.NodeTypes.CommentOpen]: [],
+	    [es_html_parser_1.NodeTypes.CommentClose]: [],
+	    [es_html_parser_1.NodeTypes.Doctype]: ["open", "close", "attributes"],
+	    [es_html_parser_1.NodeTypes.DoctypeAttribute]: ["startWrapper", "value", "endWrapper"],
+	    [es_html_parser_1.NodeTypes.DoctypeAttributeValue]: [],
+	    [es_html_parser_1.NodeTypes.DoctypeAttributeWrapperEnd]: [],
+	    [es_html_parser_1.NodeTypes.DoctypeAttributeWrapperStart]: [],
+	    [es_html_parser_1.NodeTypes.DoctypeOpen]: [],
+	    [es_html_parser_1.NodeTypes.DoctypeClose]: [],
+	    [es_html_parser_1.NodeTypes.Document]: [],
+	    [es_html_parser_1.NodeTypes.OpenScriptTagEnd]: [],
+	    [es_html_parser_1.NodeTypes.OpenScriptTagStart]: [],
+	    [es_html_parser_1.NodeTypes.OpenStyleTagEnd]: [],
+	    [es_html_parser_1.NodeTypes.OpenStyleTagStart]: [],
+	    [es_html_parser_1.NodeTypes.OpenTagEnd]: [],
+	    [es_html_parser_1.NodeTypes.OpenTagStart]: [],
+	    [es_html_parser_1.NodeTypes.ScriptTag]: [
+	        "attributes",
+	        "openStart",
+	        "openEnd",
+	        "close",
+	        "value",
+	    ],
+	    [es_html_parser_1.NodeTypes.ScriptTagContent]: [],
+	    [es_html_parser_1.NodeTypes.StyleTag]: [
+	        "attributes",
+	        "openStart",
+	        "openEnd",
+	        "close",
+	        "value",
+	    ],
+	    [es_html_parser_1.NodeTypes.StyleTagContent]: [],
+	    [es_html_parser_1.NodeTypes.Tag]: ["openStart", "openEnd", "close", "children", "attributes"],
+	    [es_html_parser_1.NodeTypes.Text]: [],
+	};
+	
+	return visitorKeys;
+}
+
+var traverse = {};
+
+var hasRequiredTraverse;
+
+function requireTraverse () {
+	if (hasRequiredTraverse) return traverse;
+	hasRequiredTraverse = 1;
+	Object.defineProperty(traverse, "__esModule", { value: true });
+	traverse.traverse = void 0;
+	const visitor_keys_1 = requireVisitorKeys();
+	function traverse$1(node, visitor) {
+	    if (!node) {
+	        return;
+	    }
+	    visitor(node);
+	    const type = node.type;
+	    const keys = visitor_keys_1.visitorKeys[type];
+	    if (!keys || keys.length <= 0) {
+	        return;
+	    }
+	    keys.forEach((key) => {
+	        // @ts-ignore
+	        const value = node[key];
+	        if (value) {
+	            if (Array.isArray(value)) {
+	                value.forEach((n) => traverse$1(n, visitor));
+	            }
+	            else {
+	                traverse$1(value, visitor);
+	            }
+	        }
+	    });
+	}
+	traverse.traverse = traverse$1;
+	
+	return traverse;
+}
+
+var hasRequiredParser;
+
+function requireParser () {
+	if (hasRequiredParser) return parser$1;
+	hasRequiredParser = 1;
+	Object.defineProperty(parser$1, "__esModule", { value: true });
+	parser$1.parseForESLint = void 0;
+	const es_html_parser_1 = requireDist$1();
+	const visitor_keys_1 = requireVisitorKeys();
+	const traverse_1 = requireTraverse();
+	function parseForESLint(code) {
+	    const { ast, tokens } = (0, es_html_parser_1.parse)(code);
+	    const programNode = {
+	        type: "Program",
+	        body: ast.children,
+	        loc: ast.loc,
+	        range: ast.range,
+	        tokens: tokens.filter((token) => token.type !== "CommentContent" &&
+	            token.type !== "CommentOpen" &&
+	            token.type !== "CommentClose"),
+	        comments: [],
+	    };
+	    (0, traverse_1.traverse)(programNode, (node) => {
+	        if (node.type === "CommentContent") {
+	            programNode.comments.push({
+	                type: node.type,
+	                range: node.range,
+	                loc: node.loc,
+	                value: node.value,
+	            });
+	        }
+	    });
+	    return {
+	        ast: programNode,
+	        visitorKeys: visitor_keys_1.visitorKeys,
+	        scopeManager: null,
+	    };
+	}
+	parser$1.parseForESLint = parseForESLint;
+	
+	return parser$1;
+}
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist$1;
+	hasRequiredDist = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.parseForESLint = void 0;
+		var parser_1 = requireParser();
+		Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } });
+		
+	} (dist$1));
+	return dist$1;
+}
+
+var node;
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node;
+	hasRequiredNode = 1;
+	// THIS IS TAKEN FROM html-eslint
+
+	const { NODE_TYPES } = requireDist();
+
+	/**
+	 * @param {TagNode | ScriptTagNode | StyleTagNode} node
+	 * @param {string} key
+	 * @returns {AttributeNode | undefined}
+	 */
+	function findAttr(node, key) {
+	  return node.attributes.find(
+	    (attr) => attr.key && attr.key.value.toLowerCase() === key.toLowerCase()
+	  );
+	}
+
+	/**
+	 * Checks whether a node's attributes is empty or not.
+	 * @param {TagNode | ScriptTagNode | StyleTagNode} node
+	 * @returns {boolean}
+	 */
+	function isAttributesEmpty(node) {
+	  return !node.attributes || node.attributes.length <= 0;
+	}
+
+	/**
+	 * Checks whether a node's all tokens are on the same line or not.
+	 * @param {AnyNode} node A node to check
+	 * @returns {boolean} `true` if a node's tokens are on the same line, otherwise `false`.
+	 */
+	function isNodeTokensOnSameLine(node) {
+	  return node.loc.start.line === node.loc.end.line;
+	}
+
+	/**
+	 *
+	 * @param {Range} rangeA
+	 * @param {Range} rangeB
+	 * @returns {boolean}
+	 */
+	function isRangesOverlap(rangeA, rangeB) {
+	  return rangeA[0] < rangeB[1] && rangeB[0] < rangeA[1];
+	}
+
+	/**
+	 * @param {(TextNode | CommentContentNode)['templates']} templates
+	 * @param {Range} range
+	 * @returns {boolean}
+	 */
+	function isOverlapWithTemplates(templates, range) {
+	  return templates
+	    .filter((template) => template.isTemplate)
+	    .some((template) => isRangesOverlap(template.range, range));
+	}
+
+	/**
+	 *
+	 * @param {TextNode | CommentContentNode} node
+	 * @returns {LineNode[]}
+	 */
+	function splitToLineNodes(node) {
+	  let start = node.range[0];
+	  let line = node.loc.start.line;
+	  const startCol = node.loc.start.column;
+	  /**
+	   * @type {LineNode[]}
+	   */
+	  const lineNodes = [];
+	  const templates = node.templates || [];
+	  /**
+	   *
+	   * @param {import("../../types").Range} range
+	   */
+	  function shouldSkipIndentCheck(range) {
+	    const overlappedTemplates = templates.filter(
+	      (template) =>
+	        template.isTemplate && isRangesOverlap(template.range, range)
+	    );
+
+	    const isLineInTemplate = overlappedTemplates.some((template) => {
+	      return template.range[0] <= range[0] && template.range[1] >= range[1];
+	    });
+	    if (isLineInTemplate) {
+	      return true;
+	    }
+	    const isLineBeforeTemplate = overlappedTemplates.some((template) => {
+	      return template.range[0] <= range[0] && template.range[1] <= range[1];
+	    });
+	    if (isLineBeforeTemplate) {
+	      return true;
+	    }
+	    const isLineAfterTemplate = overlappedTemplates.some((template) => {
+	      return template.range[1] <= range[0];
+	    });
+	    if (isLineAfterTemplate) {
+	      return true;
+	    }
+	    return false;
+	  }
+
+	  node.value.split("\n").forEach((value, index) => {
+	    const columnStart = index === 0 ? startCol : 0;
+	    /**
+	     * @type {import("../../types").Range}
+	     */
+	    const range = [start, start + value.length];
+	    const loc = {
+	      start: {
+	        line,
+	        column: columnStart,
+	      },
+	      end: {
+	        line,
+	        column: columnStart + value.length,
+	      },
+	    };
+	    /**
+	     * @type {LineNode}
+	     */
+	    const lineNode = {
+	      type: "Line",
+	      value,
+	      range,
+	      loc,
+	      skipIndentCheck: shouldSkipIndentCheck(range),
+	    };
+
+	    start += value.length + 1;
+	    line += 1;
+
+	    lineNodes.push(lineNode);
+	  });
+
+	  return lineNodes;
+	}
+
+	/**
+	 * Get location between two nodes.
+	 * @param {BaseNode} before A node placed in before
+	 * @param {BaseNode} after A node placed in after
+	 * @returns {Location} location between two nodes.
+	 */
+	function getLocBetween(before, after) {
+	  return {
+	    start: before.loc.end,
+	    end: after.loc.start,
+	  };
+	}
+
+	/**
+	 * @param {AttributeValueNode} node
+	 * @return {boolean}
+	 */
+	function isExpressionInTemplate(node) {
+	  if (node.type === NODE_TYPES.AttributeValue) {
+	    return node.value.indexOf("${") === 0;
+	  }
+	  return false;
+	}
+
+	/**
+	 * @param {AnyNode} node
+	 * @returns {node is TagNode}
+	 */
+	function isTag(node) {
+	  return node.type === NODE_TYPES.Tag;
+	}
+
+	/**
+	 * @param {AnyNode} node
+	 * @returns {node is CommentNode}
+	 */
+	function isComment(node) {
+	  return node.type === NODE_TYPES.Comment;
+	}
+
+	/**
+	 * @param {AnyNode} node
+	 * @returns {node is TextNode}
+	 */
+	function isText(node) {
+	  return node.type === NODE_TYPES.Text;
+	}
+
+	const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
+	const lineEndingPattern = new RegExp(lineBreakPattern.source, "gu");
+	/**
+	 * @param {string} source
+	 * @returns {string[]}
+	 */
+	function codeToLines(source) {
+	  return source.split(lineEndingPattern);
+	}
+
+	/**
+	 *
+	 * @param {AnyToken[]} tokens
+	 * @returns {((CommentContentNode | TextNode)['templates'][number])[]}
+	 */
+	function getTemplateTokens(tokens) {
+	  return (
+	    []
+	      .concat(
+	        ...tokens
+	          // @ts-ignore
+	          .map((token) => token["templates"] || [])
+	      )
+	      // @ts-ignore
+	      .filter((token) => token.isTemplate)
+	  );
+	}
+
+	node = {
+	  findAttr,
+	  isAttributesEmpty,
+	  isNodeTokensOnSameLine,
+	  splitToLineNodes,
+	  getLocBetween,
+	  isExpressionInTemplate,
+	  isTag,
+	  isComment,
+	  isText,
+	  isOverlapWithTemplates,
+	  codeToLines,
+	  isRangesOverlap,
+	  getTemplateTokens,
+	};
+	return node;
+}
+
+var noBemClass;
+var hasRequiredNoBemClass;
+
+function requireNoBemClass () {
+	if (hasRequiredNoBemClass) return noBemClass;
+	hasRequiredNoBemClass = 1;
+	const {
+	    findAttr,
+	    isAttributesEmpty
+	  } = requireNode();
+
+	noBemClass = {
+	    meta: {
+	      type: "problem", // The rule type
+	      docs: {
+	        description: "Enforce consistent class naming using BEM convention",
+	        category: "Stylistic Issues",
+	        recommended: true,
+	      },
+	      fixable: "code", // This rule can be fixed automatically
+	      schema: [
+	        {
+	          type: "object",
+	          properties: {
+	            pattern: { type: "string" }, // Regex pattern for BEM
+	            flags: { type: "string" }, // Regex flags
+	          },
+	          additionalProperties: false,
+	        },
+	      ],
+	      messages: {
+	        wrongClassName:
+	          "The class '{{actual}}' does not follow BEM naming convention.",
+	      },
+	    },
+	  
+	    create(context) {
+	      const pattern =
+	         /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(__[a-z0-9]+(?:-[a-z0-9]+)*)?(--[a-z0-9]+(?:-[a-z0-9]+)*)?$/;
+	        
+
+	        const checkNaming = (name) => { 
+	            
+	            return pattern.test(name) 
+	        }; 
+	        
+	        function check(node) {
+	          if (isAttributesEmpty(node)) {
+	              return;
+	          }
+	          const classAttr = findAttr(node, "class");
+	            if (classAttr && classAttr.value) {
+	              const classNames = classAttr.value.value.split(/\s+/);
+	              classNames.forEach((className) => {
+	                  if (className && !checkNaming(className)) {
+
+	                      // Find the exact location of the problematic class name
+	                      const classNameStart = classAttr.value.value.indexOf(className) +7; // 7 here is for `class= "`
+	                      const classNameEnd = classNameStart + className.length;
+
+	                      // Use the loc property to get line and column from the class attribute
+	                      const startLoc = {
+	                          line: classAttr.loc.start.line,
+	                          column: classAttr.loc.start.column + classNameStart,
+	                      };
+	                      const endLoc = {
+	                          line: classAttr.loc.start.line,
+	                          column: classAttr.loc.start.column + classNameEnd,
+	                      };
+
+	                      context.report({
+	                          node,
+	                          loc: { start: startLoc, end: endLoc },
+	                          data: {
+	                              actual: className,
+	                          },
+	                          messageId: "wrongClassName",
+	                      });
+	                  }
+	              });
+	          }
+	      }
+	      return {
+	        Tag: check,
+	      };
+	    },
+	  };
+	return noBemClass;
+}
+
+var noDeprecatedSldsClasses;
+var hasRequiredNoDeprecatedSldsClasses;
+
+function requireNoDeprecatedSldsClasses () {
+	if (hasRequiredNoDeprecatedSldsClasses) return noDeprecatedSldsClasses;
+	hasRequiredNoDeprecatedSldsClasses = 1;
+	const fs = require$$0__default["default"];
+	const path = require$$1__default["default"];
+	const { findAttr, isAttributesEmpty } = requireNode();
+
+	noDeprecatedSldsClasses = {
+	  meta: {
+	    type: "problem", // The rule type
+	    docs: {
+	      description: "Disallow usage of deprecated CSS classes",
+	      category: "Best Practices",
+	      recommended: true,
+	    },
+	    schema: [], // No additional options needed
+	    messages: {
+	      deprecatedClass: "The class '{{className}}' is deprecated and should not be used.",
+	    },
+	  },
+
+	  create(context) {
+	    let deprecatedClassesPath = path.resolve(
+	      __dirname, 
+	      "./public/metadata/deprecatedClasses.json"
+	    );
+	    if(process.env.NODE_ENV === 'test')
+	    {
+	      // In case of testing, we grab the json from local folder.
+	      deprecatedClassesPath = path.resolve(
+	        __dirname, 
+	        "./../../public/metadata/deprecatedClasses.json"
+	      );
+	    }
+
+	    //console.log(`deprecatedClassesPath ${deprecatedClassesPath}`)
+
+	    let deprecatedClasses = [];
+	    try {
+	      const fileContent = fs.readFileSync(deprecatedClassesPath, "utf8");
+	      deprecatedClasses = JSON.parse(fileContent);
+	    } catch (error) {
+	      console.error(`Failed to load deprecated classes JSON: ${error.message}`);
+	      return {}; // Exit gracefully if JSON cannot be loaded
+	    }
+
+	    function check(node) {
+	      if (isAttributesEmpty(node)) {
+	        return;
+	      }
+
+	      const classAttr = findAttr(node, "class");
+	      if (classAttr && classAttr.value) {
+	        const classNames = classAttr.value.value.split(/\s+/);
+	        classNames.forEach((className) => {
+	          if (className && deprecatedClasses.includes(className)) {
+	            // Find the exact location of the problematic class name
+	            const classNameStart = classAttr.value.value.indexOf(className) +7; // 7 here is for `class= "`
+	            const classNameEnd = classNameStart + className.length;
+
+	            // Use the loc property to get line and column from the class attribute
+	            const startLoc = {
+	                line: classAttr.loc.start.line,
+	                column: classAttr.loc.start.column + classNameStart,
+	            };
+	            const endLoc = {
+	                line: classAttr.loc.start.line,
+	                column: classAttr.loc.start.column + classNameEnd,
+	            };
+	            
+	            
+	            context.report({
+	              node,
+	              loc: { start: startLoc, end: endLoc },
+	              data: {
+	                className,
+	              },
+	              messageId: "deprecatedClass",
+	            });
+	          }
+	        });
+	      }
+	    }
+
+	    return {
+	      Tag: check,
+	    };
+	  },
+	};
+	return noDeprecatedSldsClasses;
+}
+
+var src;
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	src = {
+	    rules: {
+	        "no-bem-class": requireNoBemClass(),
+	        "no-deprecated-slds-classes": requireNoDeprecatedSldsClasses()
+	    },
+	    configs: {
+	        recommended: {
+	            parser: "@html-eslint/parser", // Use HTML parser
+	            plugins: ["sf-sds"],  
+	            rules: {
+	                "sf-sds/no-bem-class": "error", 
+	                "sf-sds/no-deprecated-slds-classes": "error"
+	            },
+	        },
+	    },
+	};
+	return src;
+}
+
+var srcExports = requireSrc();
+var index = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+
+module.exports = index;
+//# sourceMappingURL=index.js.map