svg-eslint-parser 0.0.4 → 0.0.5

package/dist/index.mjs

@@ -1,2183 +0,0 @@
-import { unionWith } from 'eslint-visitor-keys';
-
-const name$1 = "svg-eslint-parser";
-const version = "0.0.4";
-
-const meta = {
-  name: name$1,
-  version
-};
-
-class ParseError extends SyntaxError {
-  index;
-  lineNumber;
-  column;
-  constructor(message, offset, line, column) {
-    super(message);
-    this.name = "ParseError";
-    this.index = offset;
-    this.lineNumber = line;
-    this.column = column;
-  }
-}
-
-const COMMENT_START = "<!--";
-const COMMENT_END = "-->";
-const XML_DECLARATION_START = "<?xml";
-const XML_DECLARATION_END = "?>";
-const RE_OPEN_TAG_START = /^<\w/;
-const RE_OPEN_TAG_NAME = /^<(\S+)/;
-const RE_CLOSE_TAG_NAME = /^<\/((?:.|\n)*)>$/;
-const RE_INCOMPLETE_CLOSING_TAG = /<\/[^>]+$/;
-
-var NodeTypes = /* @__PURE__ */ ((NodeTypes2) => {
-  NodeTypes2["Attribute"] = "Attribute";
-  NodeTypes2["AttributeKey"] = "AttributeKey";
-  NodeTypes2["AttributeValue"] = "AttributeValue";
-  NodeTypes2["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
-  NodeTypes2["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
-  NodeTypes2["CloseTag"] = "CloseTag";
-  NodeTypes2["Comment"] = "Comment";
-  NodeTypes2["CommentClose"] = "CommentClose";
-  NodeTypes2["CommentContent"] = "CommentContent";
-  NodeTypes2["CommentOpen"] = "CommentOpen";
-  NodeTypes2["Doctype"] = "Doctype";
-  NodeTypes2["DoctypeAttribute"] = "DoctypeAttribute";
-  NodeTypes2["DoctypeAttributeValue"] = "DoctypeAttributeValue";
-  NodeTypes2["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
-  NodeTypes2["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
-  NodeTypes2["DoctypeClose"] = "DoctypeClose";
-  NodeTypes2["DoctypeOpen"] = "DoctypeOpen";
-  NodeTypes2["Document"] = "Document";
-  NodeTypes2["OpenTagEnd"] = "OpenTagEnd";
-  NodeTypes2["OpenTagStart"] = "OpenTagStart";
-  NodeTypes2["Program"] = "Program";
-  NodeTypes2["Tag"] = "Tag";
-  NodeTypes2["Text"] = "Text";
-  NodeTypes2["XMLDeclaration"] = "XMLDeclaration";
-  NodeTypes2["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-  NodeTypes2["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-  NodeTypes2["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-  NodeTypes2["XMLDeclarationAttributeValueWrapperEnd"] = "XMLDeclarationAttributeValueWrapperEnd";
-  NodeTypes2["XMLDeclarationAttributeValueWrapperStart"] = "XMLDeclarationAttributeValueWrapperStart";
-  NodeTypes2["XMLDeclarationClose"] = "XMLDeclarationClose";
-  NodeTypes2["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-  return NodeTypes2;
-})(NodeTypes || {});
-
-var TokenTypes = /* @__PURE__ */ ((TokenTypes2) => {
-  TokenTypes2["Attribute"] = "Attribute";
-  TokenTypes2["AttributeAssignment"] = "AttributeAssignment";
-  TokenTypes2["AttributeKey"] = "AttributeKey";
-  TokenTypes2["AttributeValue"] = "AttributeValue";
-  TokenTypes2["AttributeValueWrapperEnd"] = "AttributeValueWrapperEnd";
-  TokenTypes2["AttributeValueWrapperStart"] = "AttributeValueWrapperStart";
-  TokenTypes2["CloseTag"] = "CloseTag";
-  TokenTypes2["Comment"] = "Comment";
-  TokenTypes2["CommentClose"] = "CommentClose";
-  TokenTypes2["CommentContent"] = "CommentContent";
-  TokenTypes2["CommentOpen"] = "CommentOpen";
-  TokenTypes2["Doctype"] = "Doctype";
-  TokenTypes2["DoctypeAttributeValue"] = "DoctypeAttributeValue";
-  TokenTypes2["DoctypeAttributeWrapperEnd"] = "DoctypeAttributeWrapperEnd";
-  TokenTypes2["DoctypeAttributeWrapperStart"] = "DoctypeAttributeWrapperStart";
-  TokenTypes2["DoctypeClose"] = "DoctypeClose";
-  TokenTypes2["DoctypeOpen"] = "DoctypeOpen";
-  TokenTypes2["Document"] = "Document";
-  TokenTypes2["OpenTagEnd"] = "OpenTagEnd";
-  TokenTypes2["OpenTagStart"] = "OpenTagStart";
-  TokenTypes2["Program"] = "Program";
-  TokenTypes2["Tag"] = "Tag";
-  TokenTypes2["Text"] = "Text";
-  TokenTypes2["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-  TokenTypes2["XMLDeclarationAttributeAssignment"] = "XMLDeclarationAttributeAssignment";
-  TokenTypes2["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-  TokenTypes2["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-  TokenTypes2["XMLDeclarationAttributeValueWrapperEnd"] = "XMLDeclarationAttributeValueWrapperEnd";
-  TokenTypes2["XMLDeclarationAttributeValueWrapperStart"] = "XMLDeclarationAttributeValueWrapperStart";
-  TokenTypes2["XMLDeclarationClose"] = "XMLDeclarationClose";
-  TokenTypes2["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-  return TokenTypes2;
-})(TokenTypes || {});
-
-const SPECIAL_CHAR = {
-  closingCorner: `>`,
-  colon: `:`,
-  comma: `,`,
-  doubleQuote: `"`,
-  equal: `=`,
-  exclamation: `!`,
-  hyphen: `-`,
-  newline: `
-`,
-  openingCorner: `<`,
-  question: `?`,
-  return: `\r`,
-  singleQuote: `'`,
-  slash: `/`,
-  space: ` `,
-  tab: `	`
-};
-
-const SVG_ELEMENTS = /* @__PURE__ */ new Set([
-  "a",
-  "animate",
-  "animateMotion",
-  "animateTransform",
-  "circle",
-  "clipPath",
-  // not listed in mdn docs
-  "color-profile",
-  "defs",
-  "desc",
-  "ellipse",
-  "feBlend",
-  "feColorMatrix",
-  "feComponentTransfer",
-  "feComposite",
-  "feConvolveMatrix",
-  "feDiffuseLighting",
-  "feDisplacementMap",
-  "feDistantLight",
-  "feDropShadow",
-  "feFlood",
-  "feFuncA",
-  "feFuncB",
-  "feFuncG",
-  "feFuncR",
-  "feGaussianBlur",
-  "feImage",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "fePointLight",
-  "feSpecularLighting",
-  "feSpotLight",
-  "feTile",
-  "feTurbulence",
-  "filter",
-  "foreignObject",
-  "g",
-  "image",
-  "line",
-  "linearGradient",
-  "marker",
-  "mask",
-  "metadata",
-  "mpath",
-  "path",
-  "pattern",
-  "polygon",
-  "polyline",
-  "radialGradient",
-  "rect",
-  "script",
-  "set",
-  "stop",
-  "style",
-  "svg",
-  "switch",
-  "symbol",
-  "text",
-  "textPath",
-  "title",
-  "tspan",
-  "use",
-  "view"
-]);
-const DEPRECATED_SVG_ELEMENTS = /* @__PURE__ */ new Set([
-  "altGlyph",
-  "altGlyphDef",
-  "altGlyphItem",
-  "animateColor",
-  "cursor",
-  "font",
-  "font-face",
-  "font-face-format",
-  "font-face-name",
-  "font-face-src",
-  "font-face-uri",
-  "glyph",
-  "glyphRef",
-  "hkern",
-  "missing-glyph",
-  "tref",
-  "vkern"
-]);
-const SELF_CLOSING_ELEMENTS = /* @__PURE__ */ new Set([
-  "animate",
-  "animateMotion",
-  "animateTransform",
-  "circle",
-  "ellipse",
-  "feBlend",
-  "feColorMatrix",
-  "feComposite",
-  "feConvolveMatrix",
-  "feDisplacementMap",
-  "feDropShadow",
-  "feFlood",
-  "feGaussianBlur",
-  "feImage",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "fePointLight",
-  "feSpotLight",
-  "feTile",
-  "feTurbulence",
-  "image",
-  "line",
-  "mpath",
-  "path",
-  "polygon",
-  "polyline",
-  "rect",
-  "set",
-  "stop",
-  "use",
-  "view"
-]);
-
-var TokenizerContextTypes = /* @__PURE__ */ ((TokenizerContextTypes2) => {
-  TokenizerContextTypes2["AttributeKey"] = "AttributeKey";
-  TokenizerContextTypes2["Attributes"] = "Attributes";
-  TokenizerContextTypes2["AttributeValue"] = "AttributeValue";
-  TokenizerContextTypes2["AttributeValueBare"] = "AttributeValueBare";
-  TokenizerContextTypes2["AttributeValueWrapped"] = "AttributeValueWrapped";
-  TokenizerContextTypes2["CloseTag"] = "CloseTag";
-  TokenizerContextTypes2["CommentClose"] = "CommentClose";
-  TokenizerContextTypes2["CommentContent"] = "CommentContent";
-  TokenizerContextTypes2["CommentOpen"] = "CommentOpen";
-  TokenizerContextTypes2["Data"] = "Data";
-  TokenizerContextTypes2["DoctypeAttributeBare"] = "DoctypeAttributeBare";
-  TokenizerContextTypes2["DoctypeAttributes"] = "DoctypeAttributes";
-  TokenizerContextTypes2["DoctypeAttributeWrapped"] = "DoctypeAttributeWrapped";
-  TokenizerContextTypes2["DoctypeClose"] = "DoctypeClose";
-  TokenizerContextTypes2["DoctypeOpen"] = "DoctypeOpen";
-  TokenizerContextTypes2["OpenTagEnd"] = "OpenTagEnd";
-  TokenizerContextTypes2["OpenTagStart"] = "OpenTagStart";
-  TokenizerContextTypes2["XMLDeclarationAttributeKey"] = "XMLDeclarationAttributeKey";
-  TokenizerContextTypes2["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
-  TokenizerContextTypes2["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-  TokenizerContextTypes2["XMLDeclarationAttributeValueWrapped"] = "XMLDeclarationAttributeValueWrapped";
-  TokenizerContextTypes2["XMLDeclarationClose"] = "XMLDeclarationClose";
-  TokenizerContextTypes2["XMLDeclarationOpen"] = "XMLDeclarationOpen";
-  return TokenizerContextTypes2;
-})(TokenizerContextTypes || {});
-
-var ConstructTreeContextTypes = /* @__PURE__ */ ((ConstructTreeContextTypes2) => {
-  ConstructTreeContextTypes2["Attribute"] = "Attribute";
-  ConstructTreeContextTypes2["Attributes"] = "Attributes";
-  ConstructTreeContextTypes2["AttributeValue"] = "AttributeValue";
-  ConstructTreeContextTypes2["Comment"] = "Comment";
-  ConstructTreeContextTypes2["Doctype"] = "Doctype";
-  ConstructTreeContextTypes2["DoctypeAttribute"] = "DoctypeAttribute";
-  ConstructTreeContextTypes2["DoctypeAttributes"] = "DoctypeAttributes";
-  ConstructTreeContextTypes2["Tag"] = "Tag";
-  ConstructTreeContextTypes2["TagContent"] = "TagContent";
-  ConstructTreeContextTypes2["TagName"] = "TagName";
-  ConstructTreeContextTypes2["XMLDeclaration"] = "XMLDeclaration";
-  ConstructTreeContextTypes2["XMLDeclarationAttribute"] = "XMLDeclarationAttribute";
-  ConstructTreeContextTypes2["XMLDeclarationAttributes"] = "XMLDeclarationAttributes";
-  ConstructTreeContextTypes2["XMLDeclarationAttributeValue"] = "XMLDeclarationAttributeValue";
-  return ConstructTreeContextTypes2;
-})(ConstructTreeContextTypes || {});
-
-function first(items) {
-  return items[0];
-}
-function last(items) {
-  return items[items.length - 1];
-}
-
-function cloneRange(range) {
-  return [range[0], range[1]];
-}
-
-function initChildrenIfNone(node) {
-  if (!node.children) {
-    node.children = [];
-  }
-}
-function initAttributesIfNone(node) {
-  if (!node.attributes) {
-    node.attributes = [];
-  }
-}
-
-function clearParent(ast) {
-  const cleanAst = ast;
-  delete cleanAst.parentRef;
-  if (Array.isArray(ast.children)) {
-    cleanAst.children = ast.children.map((node) => {
-      return clearParent(node);
-    });
-  }
-  return cleanAst;
-}
-
-function isNewLine(code) {
-  return code === 10 || code === 13 || code === 8232 || code === 8233;
-}
-function nextLineBreak(code, from, end = code.length) {
-  for (let i = from; i < end; i++) {
-    const next = code.codePointAt(i);
-    if (!next) {
-      continue;
-    }
-    if (isNewLine(next)) {
-      return i < end - 1 && next === 13 && code.codePointAt(i + 1) === 10 ? i + 2 : i + 1;
-    }
-  }
-  return -1;
-}
-function getLineInfo(input, offset) {
-  for (let line = 1, cur = 0; ; ) {
-    const nextBreak = nextLineBreak(input, cur, offset);
-    if (nextBreak < 0) return { line, column: offset - cur };
-    ++line;
-    cur = nextBreak;
-  }
-}
-
-function isWhitespace(char) {
-  return char === SPECIAL_CHAR.space || char === SPECIAL_CHAR.newline || char === SPECIAL_CHAR.return || char === SPECIAL_CHAR.tab;
-}
-
-function cloneLocation(loc) {
-  return {
-    start: {
-      line: loc.start.line,
-      column: loc.start.column
-    },
-    end: {
-      line: loc.end.line,
-      column: loc.end.column
-    }
-  };
-}
-
-function updateNodeEnd(node, token) {
-  node.range[1] = token.range[1];
-  node.loc.end = {
-    ...token.loc.end
-  };
-}
-
-function createNodeFrom(token) {
-  const loc = cloneLocation(token.loc);
-  const range = cloneRange(token.range);
-  const result = {
-    type: token.type,
-    value: token.value,
-    loc,
-    range
-  };
-  return result;
-}
-
-function getLastAttribute(state) {
-  const attributes = state.currentNode.attributes;
-  return last(attributes);
-}
-
-function parseOpenTagName(openTagStartTokenContent) {
-  const match = openTagStartTokenContent.match(RE_OPEN_TAG_NAME);
-  if (match === null) {
-    throw new Error(
-      `Unable to parse open tag name.
-${openTagStartTokenContent} does not match pattern of opening tag.`
-    );
-  }
-  return match[1].toLowerCase();
-}
-
-function parseCloseTagName(closeTagTokenContent) {
-  const match = closeTagTokenContent.match(RE_CLOSE_TAG_NAME);
-  if (match === null) {
-    throw new Error(
-      `Unable to parse close tag name.
-${closeTagTokenContent} does not match pattern of closing tag.`
-    );
-  }
-  return match[1].trim().toLowerCase();
-}
-
-function calculateTokenLocation(source, range) {
-  return {
-    start: getLineInfo(source, range[0]),
-    end: getLineInfo(source, range[1])
-  };
-}
-
-function calculateTokenCharactersRange(state, options) {
-  const startPosition = state.sourceCode.index() - (state.accumulatedContent.length() - 1) - state.decisionBuffer.length();
-  let endPosition;
-  if (!options.keepBuffer) {
-    endPosition = state.sourceCode.index() - state.decisionBuffer.length();
-  } else {
-    endPosition = state.sourceCode.index();
-  }
-  return [startPosition, endPosition + 1];
-}
-
-function calculateTokenPosition(state, options) {
-  const range = calculateTokenCharactersRange(state, options);
-  const loc = calculateTokenLocation(state.sourceCode.source, range);
-  return {
-    range,
-    loc
-  };
-}
-
-const ATTRIBUTE_START_TOKENS$2 = /* @__PURE__ */ new Set([
-  TokenTypes.AttributeKey,
-  TokenTypes.AttributeAssignment
-]);
-function construct$d(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    return handleOpenTagStart$1(state, token);
-  }
-  if (ATTRIBUTE_START_TOKENS$2.has(token.type)) {
-    return handleAttributeStart$1(state);
-  }
-  if (token.type === TokenTypes.OpenTagEnd) {
-    return handleOpenTagEnd$2(state, token);
-  }
-  if (token.type === TokenTypes.CloseTag) {
-    return handleCloseTag$1(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagStart$1(state, token) {
-  state.currentNode.openStart = createNodeFrom(token);
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.TagName
-  };
-  return state;
-}
-function handleAttributeStart$1(state) {
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.Attributes
-  };
-  return state;
-}
-function handleOpenTagEnd$2(state, token) {
-  const tagName = state.currentNode.name;
-  state.currentNode.openEnd = createNodeFrom(token);
-  updateNodeEnd(state.currentNode, token);
-  if (tagName && SELF_CLOSING_ELEMENTS.has(tagName) && state.currentNode.openEnd.value === "/>") {
-    state.currentNode.selfClosing = true;
-    state.currentNode = state.currentNode.parentRef;
-    state.currentContext = state.currentContext.parentRef;
-    state.caretPosition++;
-    return state;
-  }
-  state.currentNode.selfClosing = false;
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.TagContent
-  };
-  state.caretPosition++;
-  return state;
-}
-function handleCloseTag$1(state, token) {
-  state.currentNode.close = createNodeFrom(token);
-  updateNodeEnd(state.currentNode, token);
-  state.currentNode = state.currentNode.parentRef;
-  state.currentContext = state.currentContext.parentRef;
-  state.caretPosition++;
-  return state;
-}
-
-const tag = {
-  __proto__: null,
-  construct: construct$d
-};
-
-function construct$c(token, state) {
-  if (token.type === TokenTypes.CommentOpen) {
-    return handleCommentOpen$1(state, token);
-  }
-  if (token.type === TokenTypes.CommentContent) {
-    return handleCommentContent(state, token);
-  }
-  if (token.type === TokenTypes.CommentClose) {
-    return handleCommentClose(state, token);
-  }
-  return state;
-}
-function handleCommentOpen$1(state, token) {
-  state.currentNode.open = createNodeFrom(token);
-  state.caretPosition++;
-  return state;
-}
-function handleCommentContent(state, token) {
-  state.currentNode.value = createNodeFrom(token);
-  state.caretPosition++;
-  return state;
-}
-function handleCommentClose(state, token) {
-  state.currentNode.close = createNodeFrom(token);
-  updateNodeEnd(state.currentNode, token);
-  state.currentNode = state.currentNode.parentRef;
-  state.currentContext = state.currentContext.parentRef;
-  state.caretPosition++;
-  return state;
-}
-
-const comment = {
-  __proto__: null,
-  construct: construct$c
-};
-
-const ATTRIBUTES_START_TOKENS = /* @__PURE__ */ new Set([
-  TokenTypes.DoctypeAttributeWrapperStart,
-  TokenTypes.DoctypeAttributeValue
-]);
-function construct$b(token, state) {
-  if (token.type === TokenTypes.DoctypeOpen) {
-    return handleDoctypeOpen$1(state, token);
-  }
-  if (token.type === TokenTypes.DoctypeClose) {
-    return handleDoctypeClose$2(state, token);
-  }
-  if (ATTRIBUTES_START_TOKENS.has(token.type)) {
-    return handleDoctypeAttributes(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeOpen$1(state, token) {
-  state.currentNode.open = createNodeFrom(token);
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose$2(state, token) {
-  state.currentNode.close = createNodeFrom(token);
-  updateNodeEnd(state.currentNode, token);
-  state.currentNode = state.currentNode.parentRef;
-  state.currentContext = state.currentContext.parentRef;
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeAttributes(state) {
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.DoctypeAttributes
-  };
-  return state;
-}
-
-const doctype = {
-  __proto__: null,
-  construct: construct$b
-};
-
-function construct$a(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    handleTagOpenStart$4(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleTagOpenStart$4(state, token) {
-  state.currentNode.name = parseOpenTagName(token.value);
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const tagName = {
-  __proto__: null,
-  construct: construct$a
-};
-
-const OPEN_TAG_END_TOKENS = /* @__PURE__ */ new Set([TokenTypes.OpenTagEnd]);
-function construct$9(token, state) {
-  if (OPEN_TAG_END_TOKENS.has(token.type)) {
-    return handleOpenTagEnd$1(state);
-  }
-  if (token.type === TokenTypes.AttributeKey) {
-    return handleAttributeKey(state, token);
-  }
-  if (token.type === TokenTypes.AttributeAssignment) {
-    return handleAttributeAssignment(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagEnd$1(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleAttributeKey(state, token) {
-  const attribute = getLastAttribute(state);
-  if (attribute.key !== void 0 || attribute.value !== void 0) {
-    state.currentContext = state.currentContext.parentRef;
-    return state;
-  }
-  attribute.key = createNodeFrom(token);
-  state.caretPosition++;
-  return state;
-}
-function handleAttributeAssignment(state) {
-  const attribute = getLastAttribute(state);
-  if (attribute.value !== void 0) {
-    state.currentContext = state.currentContext.parentRef;
-    return state;
-  }
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.AttributeValue
-  };
-  state.caretPosition++;
-  return state;
-}
-
-const attribute = {
-  __proto__: null,
-  construct: construct$9
-};
-
-const ATTRIBUTE_START_TOKENS$1 = /* @__PURE__ */ new Set([
-  TokenTypes.AttributeKey,
-  TokenTypes.AttributeAssignment
-]);
-const ATTRIBUTE_END_TOKENS = /* @__PURE__ */ new Set([TokenTypes.OpenTagEnd]);
-function construct$8(token, state) {
-  if (ATTRIBUTE_START_TOKENS$1.has(token.type)) {
-    return handleAttributeStart(state, token);
-  }
-  if (ATTRIBUTE_END_TOKENS.has(token.type)) {
-    return handleOpenTagEnd(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleAttributeStart(state, token) {
-  initAttributesIfNone(state.currentNode);
-  state.currentNode.attributes.push({
-    type: NodeTypes.Attribute,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc)
-  });
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.Attribute
-  };
-  return state;
-}
-function handleOpenTagEnd(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const attributes$1 = {
-  __proto__: null,
-  construct: construct$8
-};
-
-function construct$7(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    return handleOpenTagStart(state, token);
-  }
-  if (token.type === TokenTypes.Text) {
-    return handleText(state, token);
-  }
-  if (token.type === TokenTypes.CloseTag) {
-    return handleCloseTag(state, token);
-  }
-  if (token.type === TokenTypes.CommentOpen) {
-    return handleCommentOpen(state, token);
-  }
-  if (token.type === TokenTypes.DoctypeOpen) {
-    return handleDoctypeOpen(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagStart(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const tagNode = {
-    type: NodeTypes.Tag,
-    parentRef: state.currentNode,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc),
-    attributes: [],
-    children: []
-  };
-  state.currentNode.children.push(tagNode);
-  state.currentNode = tagNode;
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.Tag
-  };
-  return state;
-}
-function handleText(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const textNode = createNodeFrom(token);
-  state.currentNode.children.push(textNode);
-  state.caretPosition++;
-  return state;
-}
-function handleCloseTag(state, token) {
-  const closeTagName = parseCloseTagName(token.value);
-  if (closeTagName !== state.currentNode.name) {
-    state.caretPosition++;
-    return state;
-  }
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleCommentOpen(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const commentNode = {
-    type: NodeTypes.Comment,
-    parentRef: state.currentNode,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc)
-  };
-  state.currentNode.children.push(commentNode);
-  state.currentNode = commentNode;
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.Comment
-  };
-  return state;
-}
-function handleDoctypeOpen(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const doctypeNode = {
-    type: NodeTypes.Doctype,
-    parentRef: state.currentNode,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc),
-    attributes: []
-  };
-  state.currentNode.children.push(doctypeNode);
-  state.currentNode = doctypeNode;
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: ConstructTreeContextTypes.Doctype
-  };
-  return state;
-}
-
-const tagContent = {
-  __proto__: null,
-  construct: construct$7
-};
-
-const VALUE_END_TOKENS = /* @__PURE__ */ new Set([
-  TokenTypes.OpenTagEnd,
-  TokenTypes.AttributeKey,
-  TokenTypes.AttributeAssignment
-]);
-function construct$6(token, state) {
-  if (VALUE_END_TOKENS.has(token.type)) {
-    return handleValueEnd(state);
-  }
-  if (token.type === TokenTypes.AttributeValue) {
-    return handleAttributeValue(state, token);
-  }
-  if (token.type === TokenTypes.AttributeValueWrapperStart) {
-    return handleAttributeValueWrapperStart(state, token);
-  }
-  if (token.type === TokenTypes.AttributeValueWrapperEnd) {
-    return handleAttributeValueWrapperEnd(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleValueEnd(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleAttributeValue(state, token) {
-  const attribute = getLastAttribute(state);
-  attribute.value = createNodeFrom(token);
-  updateNodeEnd(attribute, token);
-  state.caretPosition++;
-  return state;
-}
-function handleAttributeValueWrapperStart(state, token) {
-  const attribute = getLastAttribute(state);
-  attribute.startWrapper = createNodeFrom(
-    token
-  );
-  if (!attribute.key) {
-    attribute.range = cloneRange(token.range);
-    attribute.loc = cloneLocation(token.loc);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleAttributeValueWrapperEnd(state, token) {
-  const attribute = getLastAttribute(state);
-  attribute.endWrapper = createNodeFrom(token);
-  updateNodeEnd(attribute, token);
-  state.caretPosition++;
-  return state;
-}
-
-const attributeValue$1 = {
-  __proto__: null,
-  construct: construct$6
-};
-
-function construct$5(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    handleTagOpenStart$3(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleTagOpenStart$3(state, token) {
-  state.currentNode.name = parseOpenTagName(token.value);
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const xmlDeclaration = {
-  __proto__: null,
-  construct: construct$5
-};
-
-function construct$4(token, state) {
-  if (token.type === TokenTypes.DoctypeClose) {
-    return handleDoctypeClose$1(state);
-  }
-  if (token.type === TokenTypes.DoctypeAttributeWrapperStart) {
-    return handleDoctypeAttributeWrapperStart(state, token);
-  }
-  if (token.type === TokenTypes.DoctypeAttributeWrapperEnd) {
-    return handleDoctypeAttributeWrapperEnd(state, token);
-  }
-  if (token.type === TokenTypes.DoctypeAttributeValue) {
-    return handleDoctypeAttributeValue(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose$1(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleDoctypeAttributeWrapperStart(state, token) {
-  const attribute = getLastAttribute(state);
-  if (attribute.value !== void 0) {
-    state.currentContext = state.currentContext.parentRef;
-    return state;
-  }
-  attribute.startWrapper = createNodeFrom(
-    token
-  );
-  attribute.range = cloneRange(token.range);
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeAttributeWrapperEnd(state, token) {
-  const attribute = getLastAttribute(state);
-  attribute.endWrapper = createNodeFrom(token);
-  updateNodeEnd(attribute, token);
-  state.currentContext = state.currentContext.parentRef;
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeAttributeValue(state, token) {
-  const attribute = getLastAttribute(state);
-  if (attribute.value !== void 0) {
-    state.currentContext = state.currentContext.parentRef;
-    return state;
-  }
-  attribute.value = createNodeFrom(token);
-  if (!attribute.startWrapper) {
-    attribute.range = cloneRange(token.range);
-  }
-  state.caretPosition++;
-  return state;
-}
-
-const doctypeAttribute = {
-  __proto__: null,
-  construct: construct$4
-};
-
-const ATTRIBUTE_START_TOKENS = /* @__PURE__ */ new Set([
-  TokenTypes.DoctypeAttributeWrapperStart,
-  TokenTypes.DoctypeAttributeValue
-]);
-function construct$3(token, state) {
-  if (token.type === TokenTypes.DoctypeClose) {
-    return handleDoctypeClose(state);
-  }
-  if (ATTRIBUTE_START_TOKENS.has(token.type)) {
-    return handleAttribute(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleAttribute(state, token) {
-  initAttributesIfNone(state.currentNode);
-  state.currentNode.attributes.push({
-    type: NodeTypes.DoctypeAttribute,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc)
-  });
-  state.currentContext = {
-    type: ConstructTreeContextTypes.DoctypeAttribute,
-    parentRef: state.currentContext
-  };
-  return state;
-}
-
-const doctypeAttributes$1 = {
-  __proto__: null,
-  construct: construct$3
-};
-
-function construct$2(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    handleTagOpenStart$2(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleTagOpenStart$2(state, token) {
-  state.currentNode.name = parseOpenTagName(token.value);
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const xmlDeclarationAttribute = {
-  __proto__: null,
-  construct: construct$2
-};
-
-function construct$1(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    handleTagOpenStart$1(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleTagOpenStart$1(state, token) {
-  state.currentNode.name = parseOpenTagName(token.value);
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const xmlDeclarationAttributes$1 = {
-  __proto__: null,
-  construct: construct$1
-};
-
-function construct(token, state) {
-  if (token.type === TokenTypes.OpenTagStart) {
-    handleTagOpenStart(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleTagOpenStart(state, token) {
-  state.currentNode.name = parseOpenTagName(token.value);
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-const xmlDeclarationAttributeValue$1 = {
-  __proto__: null,
-  construct: construct
-};
-
-const EMPTY_RANGE = [0, 0];
-const EMPTY_LOC = {
-  start: {
-    line: 1,
-    column: 0
-  },
-  end: {
-    line: 1,
-    column: 0
-  }
-};
-const contextHandlers$1 = {
-  [ConstructTreeContextTypes.Tag]: tag,
-  [ConstructTreeContextTypes.TagName]: tagName,
-  [ConstructTreeContextTypes.TagContent]: tagContent,
-  [ConstructTreeContextTypes.Attributes]: attributes$1,
-  [ConstructTreeContextTypes.Attribute]: attribute,
-  [ConstructTreeContextTypes.AttributeValue]: attributeValue$1,
-  [ConstructTreeContextTypes.Doctype]: doctype,
-  [ConstructTreeContextTypes.DoctypeAttribute]: doctypeAttribute,
-  [ConstructTreeContextTypes.DoctypeAttributes]: doctypeAttributes$1,
-  [ConstructTreeContextTypes.Comment]: comment,
-  [ConstructTreeContextTypes.XMLDeclaration]: xmlDeclaration,
-  [ConstructTreeContextTypes.XMLDeclarationAttribute]: xmlDeclarationAttribute,
-  [ConstructTreeContextTypes.XMLDeclarationAttributes]: xmlDeclarationAttributes$1,
-  [ConstructTreeContextTypes.XMLDeclarationAttributeValue]: xmlDeclarationAttributeValue$1
-};
-function constructTree(tokens) {
-  const rootContext = {
-    type: ConstructTreeContextTypes.TagContent,
-    parentRef: void 0,
-    content: []
-  };
-  const lastToken = last(tokens);
-  const firstToken = first(tokens);
-  const range = lastToken ? [0, lastToken.range[1]] : EMPTY_RANGE;
-  const loc = lastToken && firstToken ? {
-    start: cloneLocation(firstToken.loc).start,
-    end: cloneLocation(lastToken.loc).end
-  } : EMPTY_LOC;
-  loc.start.line = 1;
-  const rootNode = {
-    type: NodeTypes.Document,
-    range,
-    children: [],
-    loc
-  };
-  const state = {
-    caretPosition: 0,
-    currentContext: rootContext,
-    currentNode: rootNode,
-    rootNode
-  };
-  const positionOffset = state.caretPosition;
-  processTokens(tokens, state, positionOffset);
-  return {
-    state,
-    ast: state.rootNode
-  };
-}
-function processTokens(tokens, state, positionOffset) {
-  let tokenIndex = state.caretPosition - positionOffset;
-  while (tokenIndex < tokens.length) {
-    const token = tokens[tokenIndex];
-    const handler = contextHandlers$1[state.currentContext.type].construct;
-    state = handler(token, state);
-    tokenIndex = state.caretPosition - positionOffset;
-  }
-  return state;
-}
-
-class CharsBuffer {
-  charsBuffer = [];
-  concat(chars) {
-    const last2 = this.last();
-    if (!last2) {
-      this.charsBuffer.push(chars);
-    } else {
-      last2.concat(chars);
-    }
-  }
-  concatBuffer(buffer) {
-    this.charsBuffer.push(...buffer.charsBuffer);
-  }
-  length() {
-    return this.charsBuffer.map((chars) => chars.length()).reduce((a, b) => a + b, 0);
-  }
-  clear() {
-    this.charsBuffer = [];
-  }
-  value() {
-    return this.charsBuffer.map((chars) => chars.value).join("");
-  }
-  last() {
-    return last(this.charsBuffer);
-  }
-  first() {
-    return first(this.charsBuffer);
-  }
-  removeLast() {
-    this.charsBuffer.splice(-1, 1);
-  }
-  removeFirst() {
-    this.charsBuffer.splice(0, 1);
-  }
-  replace(other) {
-    this.charsBuffer = [...other.charsBuffer];
-  }
-}
-
-const INCOMPLETE_DOCTYPE_CHARS = /* @__PURE__ */ new Set([
-  "<!",
-  "<!D",
-  "<!DO",
-  "<!DOC",
-  // cSpell: disable
-  "<!DOCT",
-  "<!DOCTY",
-  // cSpell: enable
-  "<!DOCTYP"
-]);
-function parse$m(chars, state) {
-  const value = chars.value();
-  if (value === XML_DECLARATION_START) {
-    return parseXMLDeclarationOpen(state);
-  }
-  if (RE_OPEN_TAG_START.test(value)) {
-    return parseOpeningCornerBraceWithText(state);
-  }
-  if (value === "</") {
-    return parseOpeningCornerBraceWithSlash(state);
-  }
-  if (value === SPECIAL_CHAR.openingCorner || value === "<!" || value === "<!-") {
-    return state.sourceCode.next();
-  }
-  if (value === COMMENT_START) {
-    return parseCommentOpen(state);
-  }
-  if (isIncompleteDoctype(value)) {
-    return state.sourceCode.next();
-  }
-  if (value.toUpperCase() === "<!DOCTYPE") {
-    return parseDoctypeOpen(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function handleContentEnd(state) {
-  const textContent = state.accumulatedContent.value() + state.decisionBuffer.value();
-  if (textContent.length !== 0) {
-    const position = calculateTokenPosition(state, { keepBuffer: false });
-    state.tokens.push({
-      type: TokenTypes.Text,
-      value: textContent,
-      range: position.range,
-      loc: position.loc
-    });
-  }
-}
-function generateTextToken(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  return {
-    type: TokenTypes.Text,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  };
-}
-function isIncompleteDoctype(chars) {
-  return INCOMPLETE_DOCTYPE_CHARS.has(chars.toUpperCase());
-}
-function parseOpeningCornerBraceWithText(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.OpenTagStart;
-  state.sourceCode.next();
-}
-function parseOpeningCornerBraceWithSlash(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.CloseTag;
-  state.sourceCode.next();
-}
-function parseCommentOpen(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  const range = [
-    state.sourceCode.index() - (COMMENT_START.length - 1),
-    state.sourceCode.index() + 1
-  ];
-  state.tokens.push({
-    type: TokenTypes.CommentOpen,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.CommentContent;
-  state.sourceCode.next();
-}
-function parseDoctypeOpen(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeOpen;
-  state.sourceCode.next();
-}
-function parseXMLDeclarationOpen(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.XMLDeclarationAttributes;
-  state.sourceCode.next();
-}
-
-const data = {
-  __proto__: null,
-  handleContentEnd: handleContentEnd,
-  parse: parse$m
-};
-
-function parse$l(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace$5(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace$5(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.CloseTag,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-}
-
-const closeTag = {
-  __proto__: null,
-  parse: parse$l
-};
-
-function parse$k(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd$3(state);
-  }
-  if (value === SPECIAL_CHAR.equal) {
-    return parseEqual(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseNoneWhitespace(chars, state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseTagEnd$3(state) {
-  const tagName = state.contextParams[TokenizerContextTypes.Attributes]?.tagName;
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.OpenTagEnd;
-  state.contextParams[TokenizerContextTypes.OpenTagEnd] = { tagName };
-  state.contextParams[TokenizerContextTypes.Attributes] = void 0;
-}
-function parseEqual(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.AttributeAssignment,
-    value: state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.AttributeValue;
-  state.sourceCode.next();
-}
-function parseNoneWhitespace(chars, state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.currentContext = TokenizerContextTypes.AttributeKey;
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-
-const attributes = {
-  __proto__: null,
-  parse: parse$k
-};
-
-function parse$j(chars, state) {
-  if (chars.value() === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace$4(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace$4(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.OpenTagEnd,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
-}
-
-const openTagEnd = {
-  __proto__: null,
-  parse: parse$j
-};
-
-function parse$i(chars, state) {
-  const value = chars.value();
-  if (isWhitespace(value)) {
-    return parseWhitespace$1(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace$3(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function generateDoctypeOpenToken(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const token = {
-    type: TokenTypes.DoctypeOpen,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  };
-  return token;
-}
-function parseWhitespace$1(state) {
-  state.tokens.push(generateDoctypeOpenToken(state));
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeAttributes;
-}
-function parseClosingCornerBrace$3(state) {
-  state.tokens.push(generateDoctypeOpenToken(state));
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeClose;
-}
-
-const doctypeOpen = {
-  __proto__: null,
-  parse: parse$i
-};
-
-function parse$h(chars, state) {
-  if (isKeyBreak$1(chars)) {
-    return parseKeyEnd$1(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function isKeyBreak$1(chars) {
-  const value = chars.value();
-  return value === SPECIAL_CHAR.equal || value === SPECIAL_CHAR.slash || value === SPECIAL_CHAR.closingCorner || isWhitespace(value);
-}
-function parseKeyEnd$1(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.AttributeKey,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-}
-
-const attributeKey = {
-  __proto__: null,
-  parse: parse$h
-};
-
-function parse$g(chars, state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.DoctypeClose,
-    value: state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-}
-
-const doctypeClose = {
-  __proto__: null,
-  parse: parse$g
-};
-
-function parse$f(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd$2(state);
-  }
-  if (isWhitespace(value)) {
-    return parseWhitespace(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseTagEnd$2(state) {
-  const tagName = parseOpenTagName(state.accumulatedContent.value());
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.OpenTagStart,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.OpenTagEnd;
-  state.contextParams[TokenizerContextTypes.OpenTagEnd] = { tagName };
-}
-function parseWhitespace(state) {
-  const tagName = parseOpenTagName(state.accumulatedContent.value());
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.OpenTagStart,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-  state.contextParams[TokenizerContextTypes.Attributes] = { tagName };
-  state.sourceCode.next();
-}
-
-const openTagStart = {
-  __proto__: null,
-  parse: parse$f
-};
-
-function parse$e(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) {
-    return parseWrapper$5(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd$1(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseBare$2(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper$5(state) {
-  const wrapper = state.decisionBuffer.value();
-  const range = [state.sourceCode.index(), state.sourceCode.index() + 1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValueWrapperStart,
-    value: wrapper,
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.AttributeValueWrapped;
-  state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = {
-    wrapper
-  };
-  state.sourceCode.next();
-}
-function parseTagEnd$1(state) {
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-}
-function parseBare$2(state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.AttributeValueBare;
-  state.sourceCode.next();
-}
-
-const attributeValue = {
-  __proto__: null,
-  parse: parse$e
-};
-
-function parse$d(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.hyphen || value === "--") {
-    return state.sourceCode.next();
-  }
-  if (value === COMMENT_END) {
-    return parseCommentClose(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseCommentClose(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endRange = [
-    position.range[1],
-    position.range[1] + COMMENT_END.length
-  ];
-  state.tokens.push({
-    type: TokenTypes.CommentContent,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.tokens.push({
-    type: TokenTypes.CommentClose,
-    value: state.decisionBuffer.value(),
-    range: endRange,
-    loc: state.sourceCode.getLocationOf(endRange)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-}
-
-const commentContent = {
-  __proto__: null,
-  parse: parse$d
-};
-
-function parse$c(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) {
-    return parseWrapper$4(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace$2(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseBare$1(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper$4(state) {
-  const wrapper = state.decisionBuffer.value();
-  const range = [
-    state.sourceCode.index(),
-    state.sourceCode.index() + wrapper.length
-  ];
-  state.tokens.push({
-    type: TokenTypes.DoctypeAttributeWrapperStart,
-    value: wrapper,
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeAttributeWrapped;
-  state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped] = {
-    wrapper
-  };
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace$2(state) {
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeClose;
-}
-function parseBare$1(state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeAttributeBare;
-  state.sourceCode.next();
-}
-
-const doctypeAttributes = {
-  __proto__: null,
-  parse: parse$c
-};
-
-function parse$b(chars, state) {
-  const value = chars.value();
-  if (isWhitespace(value) || value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseValueEnd(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseValueEnd(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.AttributeValue,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-}
-
-const attributeValueBare = {
-  __proto__: null,
-  parse: parse$b
-};
-
-function parse$a(chars, state) {
-  if (chars.value() === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace$1(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace$1(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.OpenTagEnd,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
-}
-
-const xmlDeclarationOpen = {
-  __proto__: null,
-  parse: parse$a
-};
-
-function parse$9(chars, state) {
-  if (chars.value() === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: TokenTypes.OpenTagEnd,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.OpenTagEnd] = void 0;
-}
-
-const xmlDeclarationClose = {
-  __proto__: null,
-  parse: parse$9
-};
-
-function parse$8(chars, state) {
-  const value = chars.value();
-  if (isWhitespace(value) || value === SPECIAL_CHAR.closingCorner) {
-    return parseAttributeEnd(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseAttributeEnd(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.DoctypeAttributeValue,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeAttributes;
-}
-
-const doctypeAttributeBare = {
-  __proto__: null,
-  parse: parse$8
-};
-
-function parse$7(chars, state) {
-  const wrapperChar = state.contextParams[TokenizerContextTypes.AttributeValueWrapped]?.wrapper;
-  if (chars.value() === wrapperChar) {
-    return parseWrapper$3(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper$3(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endWrapperPosition = position.range[1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValue,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  const range = [endWrapperPosition, endWrapperPosition + 1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValueWrapperEnd,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = void 0;
-}
-
-const attributeValueWrapped = {
-  __proto__: null,
-  parse: parse$7
-};
-
-function parse$6(chars, state) {
-  const value = chars.value();
-  const wrapperChar = state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped]?.wrapper;
-  if (value === wrapperChar) {
-    return parseWrapper$2(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper$2(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endWrapperPosition = position.range[1];
-  state.tokens.push({
-    type: TokenTypes.DoctypeAttributeValue,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  const range = [endWrapperPosition, endWrapperPosition + 1];
-  state.tokens.push({
-    type: TokenTypes.DoctypeAttributeWrapperEnd,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.DoctypeAttributes;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.DoctypeAttributeWrapped] = void 0;
-}
-
-const doctypeAttributeWrapped = {
-  __proto__: null,
-  parse: parse$6
-};
-
-function parse$5(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.question || value === SPECIAL_CHAR.closingCorner) {
-    return parseXMLDeclarationClose(state);
-  }
-  if (value === XML_DECLARATION_END) {
-    return parseXMLDeclarationClose(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseXMLDeclarationClose(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endRange = [
-    position.range[1],
-    position.range[1] + XML_DECLARATION_END.length
-  ];
-  state.tokens.push({
-    type: TokenTypes.XMLDeclarationClose,
-    value: state.decisionBuffer.value(),
-    range: endRange,
-    loc: state.sourceCode.getLocationOf(endRange)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Data;
-  state.sourceCode.next();
-}
-
-const xmlDeclarationAttributes = {
-  __proto__: null,
-  parse: parse$5
-};
-
-function parse$4(chars, state) {
-  if (isKeyBreak(chars)) {
-    return parseKeyEnd(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function isKeyBreak(chars) {
-  const value = chars.value();
-  return value === SPECIAL_CHAR.equal || value === SPECIAL_CHAR.slash || value === SPECIAL_CHAR.closingCorner || isWhitespace(value);
-}
-function parseKeyEnd(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: TokenTypes.XMLDeclarationAttributeKey,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.XMLDeclarationAttributes;
-}
-
-const xmlDeclarationAttributeKey = {
-  __proto__: null,
-  parse: parse$4
-};
-
-function parse$3(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) {
-    return parseWrapper$1(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseBare(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper$1(state) {
-  const wrapper = state.decisionBuffer.value();
-  const range = [state.sourceCode.index(), state.sourceCode.index() + 1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValueWrapperStart,
-    value: wrapper,
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.AttributeValueWrapped;
-  state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = {
-    wrapper
-  };
-  state.sourceCode.next();
-}
-function parseTagEnd(state) {
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-}
-function parseBare(state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.AttributeValueBare;
-  state.sourceCode.next();
-}
-
-const xmlDeclarationAttributeValue = {
-  __proto__: null,
-  parse: parse$3
-};
-
-function parse$2(chars, state) {
-  const wrapperChar = state.contextParams[TokenizerContextTypes.AttributeValueWrapped]?.wrapper;
-  if (chars.value() === wrapperChar) {
-    return parseWrapper(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endWrapperPosition = position.range[1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValue,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  const range = [endWrapperPosition, endWrapperPosition + 1];
-  state.tokens.push({
-    type: TokenTypes.AttributeValueWrapperEnd,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = TokenizerContextTypes.Attributes;
-  state.sourceCode.next();
-  state.contextParams[TokenizerContextTypes.AttributeValueWrapped] = void 0;
-}
-
-const xmlDeclarationAttributeValueWrapped = {
-  __proto__: null,
-  parse: parse$2
-};
-
-const noop = {
-  parse: () => {
-  }
-};
-
-class Chars {
-  constructor(value, range) {
-    this.value = value;
-    this.range = range;
-  }
-  concat(chars) {
-    this.value += chars.value;
-    this.range[1] = chars.range[1];
-  }
-  equals(chars) {
-    return this.value === chars;
-  }
-  length() {
-    return this.value.length;
-  }
-}
-
-class SourceCode {
-  constructor(source) {
-    this.source = source;
-    this.charsList = this.createCharsList();
-  }
-  charsList;
-  charsIndex = 0;
-  getLocationOf(range) {
-    return {
-      start: getLineInfo(this.source, range[0]),
-      end: getLineInfo(this.source, range[1])
-    };
-  }
-  current() {
-    return this.charsList[this.charsIndex];
-  }
-  next() {
-    this.charsIndex++;
-  }
-  prev() {
-    this.charsIndex--;
-  }
-  isEof() {
-    return this.charsIndex >= this.charsList.length;
-  }
-  index() {
-    const current = this.current();
-    return current.range[1] - 1;
-  }
-  createCharsList() {
-    const charsList = [];
-    let sourceIndex = 0;
-    while (sourceIndex < this.source.length) {
-      charsList.push(
-        new Chars(this.source[sourceIndex], [sourceIndex, sourceIndex + 1])
-      );
-      sourceIndex++;
-    }
-    return charsList;
-  }
-}
-
-const contextHandlers = {
-  [TokenizerContextTypes.Data]: data,
-  [TokenizerContextTypes.XMLDeclarationOpen]: xmlDeclarationOpen,
-  [TokenizerContextTypes.XMLDeclarationClose]: xmlDeclarationClose,
-  [TokenizerContextTypes.XMLDeclarationAttributes]: xmlDeclarationAttributes,
-  [TokenizerContextTypes.XMLDeclarationAttributeKey]: xmlDeclarationAttributeKey,
-  [TokenizerContextTypes.XMLDeclarationAttributeValue]: xmlDeclarationAttributeValue,
-  [TokenizerContextTypes.XMLDeclarationAttributeValueWrapped]: xmlDeclarationAttributeValueWrapped,
-  [TokenizerContextTypes.Attributes]: attributes,
-  [TokenizerContextTypes.AttributeKey]: attributeKey,
-  [TokenizerContextTypes.AttributeValue]: attributeValue,
-  [TokenizerContextTypes.AttributeValueBare]: attributeValueBare,
-  [TokenizerContextTypes.AttributeValueWrapped]: attributeValueWrapped,
-  [TokenizerContextTypes.OpenTagStart]: openTagStart,
-  [TokenizerContextTypes.OpenTagEnd]: openTagEnd,
-  [TokenizerContextTypes.CloseTag]: closeTag,
-  [TokenizerContextTypes.DoctypeOpen]: doctypeOpen,
-  [TokenizerContextTypes.DoctypeClose]: doctypeClose,
-  [TokenizerContextTypes.DoctypeAttributes]: doctypeAttributes,
-  [TokenizerContextTypes.DoctypeAttributeBare]: doctypeAttributeBare,
-  [TokenizerContextTypes.DoctypeAttributeWrapped]: doctypeAttributeWrapped,
-  [TokenizerContextTypes.CommentContent]: commentContent,
-  [TokenizerContextTypes.CommentOpen]: noop,
-  [TokenizerContextTypes.CommentClose]: noop
-};
-function tokenizeChars(state) {
-  while (!state.sourceCode.isEof()) {
-    const handler2 = contextHandlers[state.currentContext];
-    state.decisionBuffer.concat(state.sourceCode.current());
-    handler2.parse(state.decisionBuffer, state);
-  }
-  const handler = contextHandlers[state.currentContext];
-  state.sourceCode.prev();
-  if (handler.handleContentEnd !== void 0) {
-    handler.handleContentEnd(state);
-  }
-}
-function tokenize(source) {
-  const tokens = [];
-  const state = {
-    contextParams: {},
-    currentContext: TokenizerContextTypes.Data,
-    sourceCode: new SourceCode(source),
-    decisionBuffer: new CharsBuffer(),
-    accumulatedContent: new CharsBuffer(),
-    tokens: {
-      push(token) {
-        tokens.push(token);
-      }
-    }
-  };
-  tokenizeChars(state);
-  return {
-    state,
-    tokens
-  };
-}
-
-function parse$1(source, _options = {}) {
-  const { tokens } = tokenize(source);
-  const { ast } = constructTree(tokens);
-  return {
-    ast: clearParent(ast),
-    tokens
-  };
-}
-
-const keys = {
-  Program: ["body"],
-  Document: ["children"],
-  XMLDeclaration: [],
-  XMLDeclarationOpen: [],
-  XMLDeclarationClose: [],
-  XMLDeclarationAttribute: ["key", "value"],
-  XMLDeclarationAttributeKey: [],
-  XMLDeclarationAttributeValue: [],
-  XMLDeclarationAttributeValueWrapperStart: [],
-  XMLDeclarationAttributeValueWrapperEnd: [],
-  Doctype: ["open", "close", "attributes"],
-  DoctypeOpen: [],
-  DoctypeClose: [],
-  DoctypeAttribute: ["key", "value"],
-  DoctypeAttributeValue: ["value"],
-  DoctypeAttributeWrapperEnd: [],
-  DoctypeAttributeWrapperStart: [],
-  Attribute: ["key", "value"],
-  AttributeKey: ["value"],
-  AttributeValue: ["value"],
-  AttributeValueWrapperEnd: [],
-  AttributeValueWrapperStart: [],
-  Tag: ["children", "attributes"],
-  OpenTagEnd: [],
-  OpenTagStart: [],
-  CloseTag: [],
-  Comment: ["open", "close", "value"],
-  CommentOpen: [],
-  CommentClose: [],
-  CommentContent: [],
-  Text: []
-};
-let vistorKeysCache = null;
-function getVisitorKeys() {
-  if (!vistorKeysCache) {
-    vistorKeysCache = unionWith(keys);
-  }
-  return vistorKeysCache;
-}
-const visitorKeys = getVisitorKeys();
-
-function traverse(node, visitor) {
-  if (!node) {
-    return;
-  }
-  visitor(node);
-  const type = node.type;
-  const keys = visitorKeys[type];
-  if (!keys || keys.length <= 0) {
-    return;
-  }
-  keys.forEach((key) => {
-    const value = node[key];
-    if (value) {
-      if (Array.isArray(value)) {
-        value.forEach((n) => traverse(n, visitor));
-      } else {
-        traverse(value, visitor);
-      }
-    }
-  });
-}
-
-function parseForESLint(source, options = {}) {
-  const { ast, tokens } = parse$1(source, options);
-  const programNode = {
-    type: NodeTypes.Program,
-    body: [ast],
-    comments: [],
-    tokens: tokens.filter(
-      (token) => token.type !== TokenTypes.CommentOpen && token.type !== TokenTypes.CommentClose && token.type !== TokenTypes.CommentContent
-    ),
-    range: ast.range,
-    loc: ast.loc
-  };
-  traverse(programNode, (node) => {
-    if (node.type === NodeTypes.CommentContent) {
-      programNode.comments.push({
-        type: node.type,
-        range: node.range,
-        loc: node.loc,
-        value: node.value
-      });
-    }
-  });
-  return {
-    ast: programNode,
-    visitorKeys,
-    scopeManager: null,
-    services: {
-      isSVG: true
-    }
-  };
-}
-
-const name = meta.name;
-const VisitorKeys = visitorKeys;
-function parse(code, options = {}) {
-  return parseForESLint(code, options).ast;
-}
-
-export { COMMENT_END, COMMENT_START, ConstructTreeContextTypes, DEPRECATED_SVG_ELEMENTS, NodeTypes, ParseError, RE_CLOSE_TAG_NAME, RE_INCOMPLETE_CLOSING_TAG, RE_OPEN_TAG_NAME, RE_OPEN_TAG_START, SELF_CLOSING_ELEMENTS, SPECIAL_CHAR, SVG_ELEMENTS, TokenTypes, TokenizerContextTypes, VisitorKeys, XML_DECLARATION_END, XML_DECLARATION_START, meta, name, parse, parseForESLint };