svg-eslint-parser 0.0.0

package/dist/index.js

@@ -0,0 +1,1681 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name3 in all)
+    __defProp(target, name3, { get: all[name3], enumerable: true });
+};
+
+// package.json
+var name = "svg-eslint-parser";
+var version = "0.0.0";
+
+// 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/char.ts
+var SPECIAL_CHAR = {
+  newline: "\n",
+  return: "\r",
+  space: " ",
+  tab: "	"
+};
+
+// 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/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/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];
+}
+
+// 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 getLastAttribute(state) {
+  const attributes = state.currentNode.attributes;
+  return last(attributes);
+}
+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 getLastAttribute2(state) {
+  const attributes = state.currentNode.attributes;
+  return last(attributes);
+}
+function handleValueEnd(state) {
+  state.currentContext = state.currentContext.parentRef;
+  return state;
+}
+function handleAttributeValue(state, token) {
+  const attribute = getLastAttribute2(state);
+  attribute.value = createNodeFrom(token);
+  updateNodeEnd(attribute, token);
+  state.caretPosition++;
+  return state;
+}
+function handleAttributeValueWrapperStart(state, token) {
+  const attribute = getLastAttribute2(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 = getLastAttribute2(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 getLastAttribute3(state) {
+  const attributes = state.currentNode.attributes;
+  return last(attributes);
+}
+function handleDoctypeClose2(state) {
+  state.currentContext = state.currentContext.parentRef;
+  return state;
+}
+function handleDoctypeAttributeWrapperStart(state, token) {
+  const attribute = getLastAttribute3(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 = getLastAttribute3(state);
+  attribute.endWrapper = createNodeFrom(token);
+  updateNodeEnd(attribute, token);
+  state.currentContext = state.currentContext.parentRef;
+  state.caretPosition++;
+  return state;
+}
+function handleDoctypeAttributeValue(state, token) {
+  const attribute = getLastAttribute3(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 === "<" || 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 === ">") {
+    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 === ">" || value === "/") {
+    return parseTagEnd(state);
+  }
+  if (value === "=") {
+    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() === ">") {
+    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 === ">") {
+    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 === "=" || value === "/" || value === ">" || 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) {
+  if (chars.value() === ">" || chars.value() === "/") {
+    return parseTagEnd2(state);
+  }
+  if (isWhitespace(chars.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 === '"' || value === `'`) {
+    return parseWrapper(state);
+  }
+  if (value === ">" || value === "/") {
+    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 === "-" || 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 === '"' || value === `'`) {
+    return parseWrapper2(state);
+  }
+  if (value === ">") {
+    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 === ">" || value === "/") {
+    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 === ">") {
+    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
+import { unionWith } from "eslint-visitor-keys";
+var keys = {
+  Program: ["body"],
+  Document: ["children"],
+  Doctype: ["open", "close", "attributes"],
+  DoctypeOpen: [],
+  DoctypeClose: [],
+  DoctypeAttribute: ["key"],
+  DoctypeAttributeKey: [],
+  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 = 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;
+export {
+  ParseError,
+  VisitorKeys,
+  meta,
+  name2 as name,
+  parseForESLint,
+  parseSVG
+};