svg-eslint-parser 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -1,1714 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ParseError: () => ParseError,
-  VisitorKeys: () => VisitorKeys,
-  meta: () => meta,
-  name: () => name2,
-  parseForESLint: () => parseForESLint,
-  parseSVG: () => parseSVG
-});
-module.exports = __toCommonJS(index_exports);
-
-// package.json
-var name = "svg-eslint-parser";
-var version = "0.0.1";
-
-// src/meta.ts
-var meta = {
-  name,
-  version
-};
-
-// src/parser/error.ts
-var ParseError = class extends SyntaxError {
-  index;
-  lineNumber;
-  column;
-  constructor(message, offset, line, column) {
-    super(message);
-    this.name = "ParseError";
-    this.index = offset;
-    this.lineNumber = line;
-    this.column = column;
-  }
-};
-
-// src/constants/parse.ts
-var COMMENT_START = "<!--";
-var COMMENT_END = "-->";
-var RE_OPEN_TAG_START = /^<\w/;
-var RE_OPEN_TAG_NAME = /^<(\S+)/;
-var RE_CLOSE_TAG_NAME = /^<\/((?:.|\n)*)>$/;
-
-// src/constants/specialChar.ts
-var SPECIAL_CHAR = {
-  closingCorner: `>`,
-  colon: `:`,
-  comma: `,`,
-  doubleQuote: `"`,
-  equal: `=`,
-  exclamation: `!`,
-  hyphen: `-`,
-  newline: `
-`,
-  openingCorner: `<`,
-  question: `?`,
-  return: `\r`,
-  singleQuote: `'`,
-  slash: `/`,
-  space: ` `,
-  tab: `	`
-};
-
-// src/constants/svgElements.ts
-var 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"
-]);
-
-// src/utils/firstLast.ts
-function first(items) {
-  return items[0];
-}
-function last(items) {
-  return items[items.length - 1];
-}
-
-// src/utils/cloneRange.ts
-function cloneRange(range) {
-  return [range[0], range[1]];
-}
-
-// src/utils/initIfNone.ts
-function initChildrenIfNone(node) {
-  if (!node.children) {
-    node.children = [];
-  }
-}
-function initAttributesIfNone(node) {
-  if (!node.attributes) {
-    node.attributes = [];
-  }
-}
-
-// src/utils/getLineInfo.ts
-function isNewLine(code) {
-  return code === 10 || code === 13 || code === 8232 || code === 8233;
-}
-function nextLineBreak(code, from, end = code.length) {
-  for (let i = from; i < end; i++) {
-    const next = code.codePointAt(i);
-    if (!next) {
-      continue;
-    }
-    if (isNewLine(next)) {
-      return i < end - 1 && next === 13 && code.codePointAt(i + 1) === 10 ? i + 2 : i + 1;
-    }
-  }
-  return -1;
-}
-function getLineInfo(input, offset) {
-  for (let line = 1, cur = 0; ; ) {
-    const nextBreak = nextLineBreak(input, cur, offset);
-    if (nextBreak < 0) return { line, column: offset - cur };
-    ++line;
-    cur = nextBreak;
-  }
-}
-
-// src/utils/clearParent.ts
-function clearParent(ast) {
-  const cleanAst = ast;
-  delete cleanAst.parentRef;
-  if (Array.isArray(ast.children)) {
-    cleanAst.children = ast.children.map((node) => {
-      return clearParent(node);
-    });
-  }
-  return cleanAst;
-}
-
-// src/utils/isWhitespace.ts
-function isWhitespace(char) {
-  return char === SPECIAL_CHAR.space || char === SPECIAL_CHAR.newline || char === SPECIAL_CHAR.return || char === SPECIAL_CHAR.tab;
-}
-
-// src/utils/cloneLocation.ts
-function cloneLocation(loc) {
-  return {
-    start: {
-      line: loc.start.line,
-      column: loc.start.column
-    },
-    end: {
-      line: loc.end.line,
-      column: loc.end.column
-    }
-  };
-}
-
-// src/utils/updateNodeEnd.ts
-function updateNodeEnd(node, token) {
-  node.range[1] = token.range[1];
-  node.loc.end = {
-    ...token.loc.end
-  };
-}
-
-// src/utils/createNodeFrom.ts
-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;
-}
-
-// src/utils/getLastAttribute.ts
-function getLastAttribute(state) {
-  const attributes = state.currentNode.attributes;
-  return last(attributes);
-}
-
-// src/utils/parseOpenTagName.ts
-function parseOpenTagName(openTagStartTokenContent) {
-  const match = openTagStartTokenContent.match(RE_OPEN_TAG_NAME);
-  if (match === null) {
-    throw new Error(
-      `Unable to parse open tag name.
-${openTagStartTokenContent} does not match pattern of opening tag.`
-    );
-  }
-  return match[1].toLowerCase();
-}
-
-// src/utils/parseCloseTagName.ts
-function parseCloseTagName(closeTagTokenContent) {
-  const match = closeTagTokenContent.match(RE_CLOSE_TAG_NAME);
-  if (match === null) {
-    throw new Error(
-      `Unable to parse close tag name.
-${closeTagTokenContent} does not match pattern of closing tag.`
-    );
-  }
-  return match[1].trim().toLowerCase();
-}
-
-// src/utils/calculateTokenLocation.ts
-function calculateTokenLocation(source, range) {
-  return {
-    start: getLineInfo(source, range[0]),
-    end: getLineInfo(source, range[1])
-  };
-}
-
-// src/utils/calculateTokenCharactersRange.ts
-function calculateTokenCharactersRange(state, options) {
-  const startPosition = state.sourceCode.index() - (state.accumulatedContent.length() - 1) - state.decisionBuffer.length();
-  let endPosition;
-  if (!options.keepBuffer) {
-    endPosition = state.sourceCode.index() - state.decisionBuffer.length();
-  } else {
-    endPosition = state.sourceCode.index();
-  }
-  return [startPosition, endPosition + 1];
-}
-
-// src/utils/calculateTokenPosition.ts
-function calculateTokenPosition(state, options) {
-  const range = calculateTokenCharactersRange(state, options);
-  const loc = calculateTokenLocation(state.sourceCode.source, range);
-  return {
-    range,
-    loc
-  };
-}
-
-// src/constructor/handlers/tag.ts
-var tag_exports = {};
-__export(tag_exports, {
-  construct: () => construct
-});
-var ATTRIBUTE_START_TOKENS = /* @__PURE__ */ new Set(["AttributeKey" /* AttributeKey */, "AttributeAssignment" /* AttributeAssignment */]);
-function construct(token, state) {
-  if (token.type === "OpenTagStart" /* OpenTagStart */) {
-    return handleOpenTagStart(state, token);
-  }
-  if (ATTRIBUTE_START_TOKENS.has(token.type)) {
-    return handleAttributeStart(state);
-  }
-  if (token.type === "OpenTagEnd" /* OpenTagEnd */) {
-    return handleOpenTagEnd(state, token);
-  }
-  if (token.type === "CloseTag" /* CloseTag */) {
-    return handleCloseTag(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagStart(state, token) {
-  state.currentNode.openStart = createNodeFrom(token);
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: "TagName" /* TagName */
-  };
-  return state;
-}
-function handleAttributeStart(state) {
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: "Attributes" /* Attributes */
-  };
-  return state;
-}
-function handleOpenTagEnd(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: "TagContent" /* TagContent */
-  };
-  state.caretPosition++;
-  return state;
-}
-function handleCloseTag(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;
-}
-
-// src/constructor/handlers/comment.ts
-var comment_exports = {};
-__export(comment_exports, {
-  construct: () => construct2
-});
-function construct2(token, state) {
-  if (token.type === "CommentOpen" /* CommentOpen */) {
-    return handleCommentOpen(state, token);
-  }
-  if (token.type === "CommentContent" /* CommentContent */) {
-    return handleCommentContent(state, token);
-  }
-  if (token.type === "CommentClose" /* CommentClose */) {
-    return handleCommentClose(state, token);
-  }
-  return state;
-}
-function handleCommentOpen(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;
-}
-
-// src/constructor/handlers/doctype.ts
-var doctype_exports = {};
-__export(doctype_exports, {
-  construct: () => construct3
-});
-var ATTRIBUTES_START_TOKENS = /* @__PURE__ */ new Set([
-  "DoctypeAttributeWrapperStart" /* DoctypeAttributeWrapperStart */,
-  "DoctypeAttributeValue" /* DoctypeAttributeValue */
-]);
-function construct3(token, state) {
-  if (token.type === "DoctypeOpen" /* DoctypeOpen */) {
-    return handleDoctypeOpen(state, token);
-  }
-  if (token.type === "DoctypeClose" /* DoctypeClose */) {
-    return handleDoctypeClose(state, token);
-  }
-  if (ATTRIBUTES_START_TOKENS.has(token.type)) {
-    return handleDoctypeAttributes(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeOpen(state, token) {
-  state.currentNode.open = createNodeFrom(token);
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose(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: "DoctypeAttributes" /* DoctypeAttributes */
-  };
-  return state;
-}
-
-// src/constructor/handlers/tagName.ts
-var tagName_exports = {};
-__export(tagName_exports, {
-  construct: () => construct4
-});
-function construct4(token, state) {
-  if (token.type === "OpenTagStart" /* 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;
-}
-
-// src/constructor/handlers/attribute.ts
-var attribute_exports = {};
-__export(attribute_exports, {
-  construct: () => construct5
-});
-var OPEN_TAG_END_TOKENS = /* @__PURE__ */ new Set(["OpenTagEnd" /* OpenTagEnd */]);
-function construct5(token, state) {
-  if (OPEN_TAG_END_TOKENS.has(token.type)) {
-    return handleOpenTagEnd2(state);
-  }
-  if (token.type === "AttributeKey" /* AttributeKey */) {
-    return handleAttributeKey(state, token);
-  }
-  if (token.type === "AttributeAssignment" /* AttributeAssignment */) {
-    return handleAttributeAssignment(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagEnd2(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: "AttributeValue" /* AttributeValue */
-  };
-  state.caretPosition++;
-  return state;
-}
-
-// src/constructor/handlers/attributes.ts
-var attributes_exports = {};
-__export(attributes_exports, {
-  construct: () => construct6
-});
-var ATTRIBUTE_START_TOKENS2 = /* @__PURE__ */ new Set(["AttributeKey" /* AttributeKey */, "AttributeAssignment" /* AttributeAssignment */]);
-var ATTRIBUTE_END_TOKENS = /* @__PURE__ */ new Set(["OpenTagEnd" /* OpenTagEnd */]);
-function construct6(token, state) {
-  if (ATTRIBUTE_START_TOKENS2.has(token.type)) {
-    return handleAttributeStart2(state, token);
-  }
-  if (ATTRIBUTE_END_TOKENS.has(token.type)) {
-    return handleOpenTagEnd3(state);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleAttributeStart2(state, token) {
-  initAttributesIfNone(state.currentNode);
-  state.currentNode.attributes.push({
-    type: "Attribute" /* Attribute */,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc)
-  });
-  state.currentContext = {
-    parentRef: state.currentContext,
-    type: "Attribute" /* Attribute */
-  };
-  return state;
-}
-function handleOpenTagEnd3(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-
-// src/constructor/handlers/tagContent.ts
-var tagContent_exports = {};
-__export(tagContent_exports, {
-  construct: () => construct7
-});
-function construct7(token, state) {
-  if (token.type === "OpenTagStart" /* OpenTagStart */) {
-    return handleOpenTagStart2(state, token);
-  }
-  if (token.type === "Text" /* Text */) {
-    return handleText(state, token);
-  }
-  if (token.type === "CloseTag" /* CloseTag */) {
-    return handleCloseTag2(state, token);
-  }
-  if (token.type === "CommentOpen" /* CommentOpen */) {
-    return handleCommentOpen2(state, token);
-  }
-  if (token.type === "DoctypeOpen" /* DoctypeOpen */) {
-    return handleDoctypeOpen2(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleOpenTagStart2(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const tagNode = {
-    type: "Tag" /* 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: "Tag" /* Tag */
-  };
-  return state;
-}
-function handleText(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const textNode = createNodeFrom(token);
-  state.currentNode.children.push(textNode);
-  state.caretPosition++;
-  return state;
-}
-function handleCloseTag2(state, token) {
-  const closeTagName = parseCloseTagName(token.value);
-  if (closeTagName !== state.currentNode.name) {
-    state.caretPosition++;
-    return state;
-  }
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleCommentOpen2(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const commentNode = {
-    type: "Comment" /* 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: "Comment" /* Comment */
-  };
-  return state;
-}
-function handleDoctypeOpen2(state, token) {
-  initChildrenIfNone(state.currentNode);
-  const doctypeNode = {
-    type: "Doctype" /* 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: "Doctype" /* Doctype */
-  };
-  return state;
-}
-
-// src/constructor/handlers/attributeValue.ts
-var attributeValue_exports = {};
-__export(attributeValue_exports, {
-  construct: () => construct8
-});
-var VALUE_END_TOKENS = /* @__PURE__ */ new Set([
-  "OpenTagEnd" /* OpenTagEnd */,
-  "AttributeKey" /* AttributeKey */,
-  "AttributeAssignment" /* AttributeAssignment */
-]);
-function construct8(token, state) {
-  if (VALUE_END_TOKENS.has(token.type)) {
-    return handleValueEnd(state);
-  }
-  if (token.type === "AttributeValue" /* AttributeValue */) {
-    return handleAttributeValue(state, token);
-  }
-  if (token.type === "AttributeValueWrapperStart" /* AttributeValueWrapperStart */) {
-    return handleAttributeValueWrapperStart(state, token);
-  }
-  if (token.type === "AttributeValueWrapperEnd" /* 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;
-}
-
-// src/constructor/handlers/doctypeAttribute.ts
-var doctypeAttribute_exports = {};
-__export(doctypeAttribute_exports, {
-  construct: () => construct9
-});
-function construct9(token, state) {
-  if (token.type === "DoctypeClose" /* DoctypeClose */) {
-    return handleDoctypeClose2(state);
-  }
-  if (token.type === "DoctypeAttributeWrapperStart" /* DoctypeAttributeWrapperStart */) {
-    return handleDoctypeAttributeWrapperStart(state, token);
-  }
-  if (token.type === "DoctypeAttributeWrapperEnd" /* DoctypeAttributeWrapperEnd */) {
-    return handleDoctypeAttributeWrapperEnd(state, token);
-  }
-  if (token.type === "DoctypeAttributeValue" /* DoctypeAttributeValue */) {
-    return handleDoctypeAttributeValue(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose2(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;
-}
-
-// src/constructor/handlers/doctypeAttributes.ts
-var doctypeAttributes_exports = {};
-__export(doctypeAttributes_exports, {
-  construct: () => construct10
-});
-var ATTRIBUTE_START_TOKENS3 = /* @__PURE__ */ new Set([
-  "DoctypeAttributeWrapperStart" /* DoctypeAttributeWrapperStart */,
-  "DoctypeAttributeValue" /* DoctypeAttributeValue */
-]);
-function construct10(token, state) {
-  if (token.type === "DoctypeClose" /* DoctypeClose */) {
-    return handleDoctypeClose3(state);
-  }
-  if (ATTRIBUTE_START_TOKENS3.has(token.type)) {
-    return handleAttribute(state, token);
-  }
-  state.caretPosition++;
-  return state;
-}
-function handleDoctypeClose3(state) {
-  state.currentContext = state.currentContext.parentRef;
-  return state;
-}
-function handleAttribute(state, token) {
-  initAttributesIfNone(state.currentNode);
-  state.currentNode.attributes.push({
-    type: "DoctypeAttribute" /* DoctypeAttribute */,
-    range: cloneRange(token.range),
-    loc: cloneLocation(token.loc)
-  });
-  state.currentContext = {
-    type: "DoctypeAttribute" /* DoctypeAttribute */,
-    parentRef: state.currentContext
-  };
-  return state;
-}
-
-// src/constructor/constructTree.ts
-var EMPTY_RANGE = [0, 0];
-var EMPTY_LOC = {
-  start: {
-    line: 1,
-    column: 0
-  },
-  end: {
-    line: 1,
-    column: 0
-  }
-};
-var contextHandlers = {
-  ["Tag" /* Tag */]: tag_exports,
-  ["TagName" /* TagName */]: tagName_exports,
-  ["TagContent" /* TagContent */]: tagContent_exports,
-  ["Attributes" /* Attributes */]: attributes_exports,
-  ["Attribute" /* Attribute */]: attribute_exports,
-  ["AttributeValue" /* AttributeValue */]: attributeValue_exports,
-  ["Doctype" /* Doctype */]: doctype_exports,
-  ["DoctypeAttribute" /* DoctypeAttribute */]: doctypeAttribute_exports,
-  ["DoctypeAttributes" /* DoctypeAttributes */]: doctypeAttributes_exports,
-  ["Comment" /* Comment */]: comment_exports
-};
-function constructTree(tokens) {
-  const rootContext = {
-    type: "TagContent" /* 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: "Document" /* 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[state.currentContext.type].construct;
-    state = handler(token, state);
-    tokenIndex = state.caretPosition - positionOffset;
-  }
-  return state;
-}
-
-// src/tokenizer/charsBuffer.ts
-var CharsBuffer = class {
-  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];
-  }
-};
-
-// src/tokenizer/handlers/data.ts
-var data_exports = {};
-__export(data_exports, {
-  handleContentEnd: () => handleContentEnd,
-  parse: () => parse
-});
-function parse(chars, state) {
-  const value = chars.value();
-  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: "Text" /* Text */,
-      value: textContent,
-      range: position.range,
-      loc: position.loc
-    });
-  }
-}
-function generateTextToken(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  return {
-    type: "Text" /* Text */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  };
-}
-function isIncompleteDoctype(chars) {
-  const charsUpperCase = chars.toUpperCase();
-  return charsUpperCase === "<!" || charsUpperCase === "<!D" || charsUpperCase === "<!DO" || charsUpperCase === "<!DOC" || // cSpell: disable-next-line
-  charsUpperCase === "<!DOCT" || // cSpell: disable-next-line
-  charsUpperCase === "<!DOCTY" || charsUpperCase === "<!DOCTYP";
-}
-function parseOpeningCornerBraceWithText(state) {
-  if (state.accumulatedContent.length() !== 0) {
-    state.tokens.push(generateTextToken(state));
-  }
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = "OpenTagStart" /* 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 = "CloseTag" /* 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: "CommentOpen" /* CommentOpen */,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "CommentContent" /* 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 = "DoctypeOpen" /* DoctypeOpen */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/closeTag.ts
-var closeTag_exports = {};
-__export(closeTag_exports, {
-  parse: () => parse2
-});
-function parse2(chars, state) {
-  const value = chars.value();
-  if (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: "CloseTag" /* CloseTag */,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Data" /* Data */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/attributes.ts
-var attributes_exports2 = {};
-__export(attributes_exports2, {
-  parse: () => parse3
-});
-function parse3(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd(state);
-  }
-  if (value === SPECIAL_CHAR.equal) {
-    return parseEqual(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseNoneWhitespace(chars, state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseTagEnd(state) {
-  const tagName = state.contextParams["Attributes" /* Attributes */]?.tagName;
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "OpenTagEnd" /* OpenTagEnd */;
-  state.contextParams["OpenTagEnd" /* OpenTagEnd */] = { tagName };
-  state.contextParams["Attributes" /* Attributes */] = void 0;
-}
-function parseEqual(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: "AttributeAssignment" /* AttributeAssignment */,
-    value: state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "AttributeValue" /* AttributeValue */;
-  state.sourceCode.next();
-}
-function parseNoneWhitespace(chars, state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.currentContext = "AttributeKey" /* AttributeKey */;
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/openTagEnd.ts
-var openTagEnd_exports = {};
-__export(openTagEnd_exports, {
-  parse: () => parse4
-});
-function parse4(chars, state) {
-  if (chars.value() === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace2(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace2(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: "OpenTagEnd" /* OpenTagEnd */,
-    value: state.accumulatedContent.value() + state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Data" /* Data */;
-  state.sourceCode.next();
-  state.contextParams["OpenTagEnd" /* OpenTagEnd */] = void 0;
-}
-
-// src/tokenizer/handlers/doctypeOpen.ts
-var doctypeOpen_exports = {};
-__export(doctypeOpen_exports, {
-  parse: () => parse5
-});
-function parse5(chars, state) {
-  const value = chars.value();
-  if (isWhitespace(value)) {
-    return parseWhitespace(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace3(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function generateDoctypeOpenToken(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const token = {
-    type: "DoctypeOpen" /* DoctypeOpen */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  };
-  return token;
-}
-function parseWhitespace(state) {
-  state.tokens.push(generateDoctypeOpenToken(state));
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeAttributes" /* DoctypeAttributes */;
-}
-function parseClosingCornerBrace3(state) {
-  state.tokens.push(generateDoctypeOpenToken(state));
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeClose" /* DoctypeClose */;
-}
-
-// src/tokenizer/handlers/doctypeClose.ts
-var doctypeClose_exports = {};
-__export(doctypeClose_exports, {
-  parse: () => parse6
-});
-function parse6(chars, state) {
-  const position = calculateTokenPosition(state, { keepBuffer: true });
-  state.tokens.push({
-    type: "DoctypeClose" /* DoctypeClose */,
-    value: state.decisionBuffer.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Data" /* Data */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/attributeKey.ts
-var attributeKey_exports = {};
-__export(attributeKey_exports, {
-  parse: () => parse7
-});
-function parse7(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: "AttributeKey" /* AttributeKey */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Attributes" /* Attributes */;
-}
-
-// src/tokenizer/handlers/openTagStart.ts
-var openTagStart_exports = {};
-__export(openTagStart_exports, {
-  parse: () => parse8
-});
-function parse8(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd2(state);
-  }
-  if (isWhitespace(value)) {
-    return parseWhitespace2(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseTagEnd2(state) {
-  const tagName = parseOpenTagName(state.accumulatedContent.value());
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: "OpenTagStart" /* OpenTagStart */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "OpenTagEnd" /* OpenTagEnd */;
-  state.contextParams["OpenTagEnd" /* OpenTagEnd */] = { tagName };
-}
-function parseWhitespace2(state) {
-  const tagName = parseOpenTagName(state.accumulatedContent.value());
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  state.tokens.push({
-    type: "OpenTagStart" /* OpenTagStart */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Attributes" /* Attributes */;
-  state.contextParams["Attributes" /* Attributes */] = { tagName };
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/attributeValue.ts
-var attributeValue_exports2 = {};
-__export(attributeValue_exports2, {
-  parse: () => parse9
-});
-function parse9(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) {
-    return parseWrapper(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner || value === SPECIAL_CHAR.slash) {
-    return parseTagEnd3(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseBare(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper(state) {
-  const wrapper = state.decisionBuffer.value();
-  const range = [state.sourceCode.index(), state.sourceCode.index() + 1];
-  state.tokens.push({
-    type: "AttributeValueWrapperStart" /* AttributeValueWrapperStart */,
-    value: wrapper,
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "AttributeValueWrapped" /* AttributeValueWrapped */;
-  state.contextParams["AttributeValueWrapped" /* AttributeValueWrapped */] = {
-    wrapper
-  };
-  state.sourceCode.next();
-}
-function parseTagEnd3(state) {
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Attributes" /* Attributes */;
-}
-function parseBare(state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = "AttributeValueBare" /* AttributeValueBare */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/commentContent.ts
-var commentContent_exports = {};
-__export(commentContent_exports, {
-  parse: () => parse10
-});
-function parse10(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: "CommentContent" /* CommentContent */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.tokens.push({
-    type: "CommentClose" /* CommentClose */,
-    value: state.decisionBuffer.value(),
-    range: endRange,
-    loc: state.sourceCode.getLocationOf(endRange)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Data" /* Data */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/doctypeAttributes.ts
-var doctypeAttributes_exports2 = {};
-__export(doctypeAttributes_exports2, {
-  parse: () => parse11
-});
-function parse11(chars, state) {
-  const value = chars.value();
-  if (value === SPECIAL_CHAR.doubleQuote || value === SPECIAL_CHAR.singleQuote) {
-    return parseWrapper2(state);
-  }
-  if (value === SPECIAL_CHAR.closingCorner) {
-    return parseClosingCornerBrace4(state);
-  }
-  if (!isWhitespace(value)) {
-    return parseBare2(state);
-  }
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper2(state) {
-  const wrapper = state.decisionBuffer.value();
-  const range = [state.sourceCode.index(), state.sourceCode.index() + wrapper.length];
-  state.tokens.push({
-    type: "DoctypeAttributeWrapperStart" /* DoctypeAttributeWrapperStart */,
-    value: wrapper,
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeAttributeWrapped" /* DoctypeAttributeWrapped */;
-  state.contextParams["DoctypeAttributeWrapped" /* DoctypeAttributeWrapped */] = {
-    wrapper
-  };
-  state.sourceCode.next();
-}
-function parseClosingCornerBrace4(state) {
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeClose" /* DoctypeClose */;
-}
-function parseBare2(state) {
-  state.accumulatedContent.replace(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeAttributeBare" /* DoctypeAttributeBare */;
-  state.sourceCode.next();
-}
-
-// src/tokenizer/handlers/attributeValueBare.ts
-var attributeValueBare_exports = {};
-__export(attributeValueBare_exports, {
-  parse: () => parse12
-});
-function parse12(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: "AttributeValue" /* AttributeValue */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Attributes" /* Attributes */;
-}
-
-// src/tokenizer/handlers/doctypeAttributeBare.ts
-var doctypeAttributeBare_exports = {};
-__export(doctypeAttributeBare_exports, {
-  parse: () => parse13
-});
-function parse13(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: "DoctypeAttributeValue" /* DoctypeAttributeValue */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeAttributes" /* DoctypeAttributes */;
-}
-
-// src/tokenizer/handlers/attributeValueWrapped.ts
-var attributeValueWrapped_exports = {};
-__export(attributeValueWrapped_exports, {
-  parse: () => parse14
-});
-function parse14(chars, state) {
-  const wrapperChar = state.contextParams["AttributeValueWrapped" /* AttributeValueWrapped */]?.wrapper;
-  if (chars.value() === wrapperChar) {
-    return parseWrapper3(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper3(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endWrapperPosition = position.range[1];
-  state.tokens.push({
-    type: "AttributeValue" /* AttributeValue */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  const range = [endWrapperPosition, endWrapperPosition + 1];
-  state.tokens.push({
-    type: "AttributeValueWrapperEnd" /* AttributeValueWrapperEnd */,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "Attributes" /* Attributes */;
-  state.sourceCode.next();
-  state.contextParams["AttributeValueWrapped" /* AttributeValueWrapped */] = void 0;
-}
-
-// src/tokenizer/handlers/doctypeAttributeWrapped.ts
-var doctypeAttributeWrapped_exports = {};
-__export(doctypeAttributeWrapped_exports, {
-  parse: () => parse15
-});
-function parse15(chars, state) {
-  const value = chars.value();
-  const wrapperChar = state.contextParams["DoctypeAttributeWrapped" /* DoctypeAttributeWrapped */]?.wrapper;
-  if (value === wrapperChar) {
-    return parseWrapper4(state);
-  }
-  state.accumulatedContent.concatBuffer(state.decisionBuffer);
-  state.decisionBuffer.clear();
-  state.sourceCode.next();
-}
-function parseWrapper4(state) {
-  const position = calculateTokenPosition(state, { keepBuffer: false });
-  const endWrapperPosition = position.range[1];
-  state.tokens.push({
-    type: "DoctypeAttributeValue" /* DoctypeAttributeValue */,
-    value: state.accumulatedContent.value(),
-    range: position.range,
-    loc: position.loc
-  });
-  const range = [endWrapperPosition, endWrapperPosition + 1];
-  state.tokens.push({
-    type: "DoctypeAttributeWrapperEnd" /* DoctypeAttributeWrapperEnd */,
-    value: state.decisionBuffer.value(),
-    range,
-    loc: state.sourceCode.getLocationOf(range)
-  });
-  state.accumulatedContent.clear();
-  state.decisionBuffer.clear();
-  state.currentContext = "DoctypeAttributes" /* DoctypeAttributes */;
-  state.sourceCode.next();
-  state.contextParams["DoctypeAttributeWrapped" /* DoctypeAttributeWrapped */] = void 0;
-}
-
-// src/tokenizer/handlers/index.ts
-var noop = {
-  parse: () => {
-  }
-};
-
-// src/tokenizer/chars.ts
-var Chars = class {
-  constructor(value, range) {
-    this.value = value;
-    this.range = range;
-  }
-  concat(chars) {
-    this.value += chars.value;
-    this.range[1] = chars.range[1];
-  }
-  equals(chars) {
-    return this.value === chars;
-  }
-  length() {
-    return this.value.length;
-  }
-};
-
-// src/tokenizer/sourceCode.ts
-var SourceCode = class {
-  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;
-  }
-};
-
-// src/tokenizer/tokenize.ts
-var contextHandlers2 = {
-  ["Data" /* Data */]: data_exports,
-  ["Attributes" /* Attributes */]: attributes_exports2,
-  ["AttributeKey" /* AttributeKey */]: attributeKey_exports,
-  ["AttributeValue" /* AttributeValue */]: attributeValue_exports2,
-  ["AttributeValueBare" /* AttributeValueBare */]: attributeValueBare_exports,
-  ["AttributeValueWrapped" /* AttributeValueWrapped */]: attributeValueWrapped_exports,
-  ["OpenTagStart" /* OpenTagStart */]: openTagStart_exports,
-  ["OpenTagEnd" /* OpenTagEnd */]: openTagEnd_exports,
-  ["CloseTag" /* CloseTag */]: closeTag_exports,
-  ["DoctypeOpen" /* DoctypeOpen */]: doctypeOpen_exports,
-  ["DoctypeClose" /* DoctypeClose */]: doctypeClose_exports,
-  ["DoctypeAttributes" /* DoctypeAttributes */]: doctypeAttributes_exports2,
-  ["DoctypeAttributeBare" /* DoctypeAttributeBare */]: doctypeAttributeBare_exports,
-  ["DoctypeAttributeWrapped" /* DoctypeAttributeWrapped */]: doctypeAttributeWrapped_exports,
-  ["CommentOpen" /* CommentOpen */]: noop,
-  ["CommentClose" /* CommentClose */]: noop,
-  ["CommentContent" /* CommentContent */]: commentContent_exports
-};
-function tokenizeChars(state) {
-  while (!state.sourceCode.isEof()) {
-    const handler2 = contextHandlers2[state.currentContext];
-    state.decisionBuffer.concat(state.sourceCode.current());
-    handler2.parse(state.decisionBuffer, state);
-  }
-  const handler = contextHandlers2[state.currentContext];
-  state.sourceCode.prev();
-  if (handler.handleContentEnd !== void 0) {
-    handler.handleContentEnd(state);
-  }
-}
-function tokenize(source) {
-  const tokens = [];
-  const state = {
-    contextParams: {},
-    currentContext: "Data" /* Data */,
-    sourceCode: new SourceCode(source),
-    decisionBuffer: new CharsBuffer(),
-    accumulatedContent: new CharsBuffer(),
-    tokens: {
-      push(token) {
-        tokens.push(token);
-      }
-    }
-  };
-  tokenizeChars(state);
-  return {
-    state,
-    tokens
-  };
-}
-
-// src/parser/parse.ts
-function parse16(source, _options = {}) {
-  const { tokens } = tokenize(source);
-  const { ast } = constructTree(tokens);
-  return {
-    ast: clearParent(ast),
-    tokens
-  };
-}
-
-// src/visitorKeys.ts
-var import_eslint_visitor_keys = require("eslint-visitor-keys");
-var keys = {
-  Program: ["body"],
-  Document: ["children"],
-  XMLDeclaration: [],
-  Doctype: ["open", "close", "attributes"],
-  DoctypeOpen: [],
-  DoctypeClose: [],
-  DoctypeAttribute: ["key"],
-  DoctypeAttributeValue: [],
-  DoctypeAttributeWrapperEnd: [],
-  DoctypeAttributeWrapperStart: [],
-  Attribute: ["key", "value"],
-  AttributeKey: [],
-  AttributeValue: [],
-  AttributeValueWrapperEnd: [],
-  AttributeValueWrapperStart: [],
-  Tag: ["children", "attributes"],
-  OpenTagEnd: [],
-  OpenTagStart: [],
-  CloseTag: [],
-  Comment: ["open", "close", "value"],
-  CommentOpen: [],
-  CommentClose: [],
-  CommentContent: [],
-  Text: []
-};
-var vistorKeysCache = null;
-function getVisitorKeys() {
-  if (!vistorKeysCache) {
-    vistorKeysCache = (0, import_eslint_visitor_keys.unionWith)(keys);
-  }
-  return vistorKeysCache;
-}
-var visitorKeys = getVisitorKeys();
-
-// src/parser/traverse.ts
-function traverse(node, visitor) {
-  if (!node) {
-    return;
-  }
-  visitor(node);
-  const type = node.type;
-  const keys2 = visitorKeys[type];
-  if (!keys2 || keys2.length <= 0) {
-    return;
-  }
-  keys2.forEach((key) => {
-    const value = node[key];
-    if (value) {
-      if (Array.isArray(value)) {
-        value.forEach((n) => traverse(n, visitor));
-      } else {
-        traverse(value, visitor);
-      }
-    }
-  });
-}
-
-// src/parser/parseForESLint.ts
-function parseForESLint(source, options = {}) {
-  const { ast, tokens } = parse16(source, options);
-  const programNode = {
-    type: "Program" /* Program */,
-    body: [ast],
-    comments: [],
-    tokens: tokens.filter(
-      (token) => token.type !== "CommentOpen" /* CommentOpen */ && token.type !== "CommentClose" /* CommentClose */ && token.type !== "CommentContent" /* CommentContent */
-    ),
-    range: ast.range,
-    loc: ast.loc
-  };
-  traverse(programNode, (node) => {
-    if (node.type === "CommentContent" /* CommentContent */) {
-      programNode.comments.push({
-        type: node.type,
-        range: node.range,
-        loc: node.loc,
-        value: node.value
-      });
-    }
-  });
-  return {
-    ast: programNode,
-    visitorKeys,
-    services: {
-      isSVG: true
-    }
-  };
-}
-
-// src/index.ts
-function parseSVG(code, options = {}) {
-  return parseForESLint(code, options).ast;
-}
-var name2 = meta.name;
-var VisitorKeys = visitorKeys;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ParseError,
-  VisitorKeys,
-  meta,
-  name,
-  parseForESLint,
-  parseSVG
-});