htmljs-parser 2.11.2 → 3.0.0

package/dist/index.js

@@ -0,0 +1,2034 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 src_exports = {};
+__export(src_exports, {
+  OpenTagEnding: () => OpenTagEnding,
+  createParser: () => createParser
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/util/constants.ts
+var OpenTagEnding = /* @__PURE__ */ ((OpenTagEnding2) => {
+  OpenTagEnding2[OpenTagEnding2["tag"] = 0] = "tag";
+  OpenTagEnding2[OpenTagEnding2["self"] = 1] = "self";
+  OpenTagEnding2[OpenTagEnding2["void"] = 2] = "void";
+  OpenTagEnding2[OpenTagEnding2["code"] = 4] = "code";
+  return OpenTagEnding2;
+})(OpenTagEnding || {});
+
+// src/util/util.ts
+function isWhitespaceCode(code) {
+  return code <= 32 /* SPACE */;
+}
+function getLoc(lines, range) {
+  const start = getPos(lines, 0, range.start);
+  const end = range.start === range.end ? start : getPos(lines, start.line, range.end);
+  return { start, end };
+}
+function getPos(lines, startLine, index) {
+  let max = lines.length - 1;
+  let line = startLine;
+  while (line < max) {
+    const mid = 1 + line + max >>> 1;
+    if (lines[mid] <= index) {
+      line = mid;
+    } else {
+      max = mid - 1;
+    }
+  }
+  return {
+    line,
+    character: index - lines[line]
+  };
+}
+function getLines(src) {
+  const lines = [-1];
+  for (let i = 0; i < src.length; i++) {
+    if (src.charCodeAt(i) === 10 /* NEWLINE */) {
+      lines.push(i);
+    }
+  }
+  return lines;
+}
+function htmlEOF() {
+  this.endText();
+  while (this.activeTag) {
+    if (this.activeTag.concise) {
+      this.closeTag(this.pos, this.pos, void 0);
+    } else {
+      return this.emitError(this.activeTag, "MISSING_END_TAG", 'Missing ending "' + this.read(this.activeTag.tagName) + '" tag');
+    }
+  }
+}
+
+// src/core/Parser.ts
+var Parser = class {
+  constructor(handlers) {
+    this.handlers = handlers;
+    this.handlers = handlers;
+  }
+  pos;
+  maxPos;
+  data;
+  activeState;
+  activeRange;
+  forward;
+  activeTag;
+  activeAttr;
+  indent;
+  isConcise;
+  beginMixedMode;
+  endingMixedModeAtEOL;
+  textPos;
+  lines;
+  read(range) {
+    return this.data.slice(range.start, range.end);
+  }
+  positionAt(index) {
+    return getPos(this.lines || (this.lines = getLines(this.data)), 0, index);
+  }
+  locationAt(range) {
+    return getLoc(this.lines || (this.lines = getLines(this.data)), range);
+  }
+  enterState(state) {
+    this.activeState = state;
+    return this.activeRange = state.enter.call(this, this.activeRange, this.pos);
+  }
+  exitState() {
+    const { activeRange, activeState } = this;
+    const parent = this.activeRange = activeRange.parent;
+    this.activeState = parent.state;
+    this.forward = 0;
+    activeRange.end = this.pos;
+    activeState.exit.call(this, activeRange);
+    this.activeState.return.call(this, activeRange, parent);
+  }
+  matchAtPos(a, b) {
+    const aPos = a.start;
+    const aLen = a.end - aPos;
+    let bPos = 0;
+    let bLen = 0;
+    let bSource = this.data;
+    if (typeof b === "string") {
+      bLen = b.length;
+      bSource = b;
+    } else {
+      bPos = b.start;
+      bLen = b.end - bPos;
+    }
+    if (aLen !== bLen)
+      return false;
+    for (let i = 0; i < aLen; i++) {
+      if (this.data.charAt(aPos + i) !== bSource.charAt(bPos + i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  matchAnyAtPos(a, list) {
+    for (const item of list) {
+      if (this.matchAtPos(a, item))
+        return true;
+    }
+    return false;
+  }
+  lookAheadFor(str, startPos = this.pos + 1) {
+    let i = str.length;
+    if (startPos + i <= this.maxPos) {
+      const { data } = this;
+      for (; i--; ) {
+        if (str[i] !== data[startPos + i]) {
+          return void 0;
+        }
+      }
+      return str;
+    }
+  }
+  lookAtCharCodeAhead(offset, startPos = this.pos) {
+    return this.data.charCodeAt(startPos + offset);
+  }
+  startText() {
+    if (this.textPos === -1) {
+      this.textPos = this.pos;
+    }
+  }
+  endText() {
+    var _a, _b;
+    const start = this.textPos;
+    if (start !== -1) {
+      (_b = (_a = this.handlers).onText) == null ? void 0 : _b.call(_a, { start, end: this.pos });
+      this.textPos = -1;
+    }
+  }
+  beginHtmlBlock(delimiter, singleLine) {
+    var _a;
+    const content = this.enterState(((_a = this.activeTag) == null ? void 0 : _a.bodyMode) === 1 /* PARSED_TEXT */ ? states_exports.PARSED_TEXT_CONTENT : states_exports.HTML_CONTENT);
+    content.singleLine = singleLine;
+    content.delimiter = delimiter;
+    content.indent = this.indent;
+  }
+  emitError(range, code, message) {
+    var _a, _b;
+    let start, end;
+    if (typeof range === "number") {
+      start = end = range;
+    } else {
+      start = range.start;
+      end = range.end;
+    }
+    (_b = (_a = this.handlers).onError) == null ? void 0 : _b.call(_a, {
+      start,
+      end,
+      code,
+      message
+    });
+    this.pos = this.maxPos + 1;
+  }
+  closeTag(start, end, value) {
+    var _a, _b;
+    const { beginMixedMode, parentTag } = this.activeTag;
+    if (beginMixedMode)
+      this.endingMixedModeAtEOL = true;
+    this.activeTag = parentTag;
+    (_b = (_a = this.handlers).onCloseTag) == null ? void 0 : _b.call(_a, {
+      start,
+      end,
+      value
+    });
+  }
+  consumeWhitespaceIfBefore(str, start = 0) {
+    const { pos, data } = this;
+    let cur = pos + start;
+    while (isWhitespaceCode(data.charCodeAt(cur)))
+      cur++;
+    if (this.lookAheadFor(str, cur)) {
+      this.pos = cur;
+      return true;
+    }
+    return false;
+  }
+  getPreviousNonWhitespaceCharCode(start = -1) {
+    let behind = start;
+    while (isWhitespaceCode(this.lookAtCharCodeAhead(behind)))
+      behind--;
+    return this.lookAtCharCodeAhead(behind);
+  }
+  onlyWhitespaceRemainsOnLine(start = 1) {
+    const maxOffset = this.maxPos - this.pos;
+    let ahead = start;
+    while (ahead < maxOffset) {
+      const code = this.lookAtCharCodeAhead(ahead);
+      if (isWhitespaceCode(code)) {
+        switch (code) {
+          case 13 /* CARRIAGE_RETURN */:
+          case 10 /* NEWLINE */:
+            return true;
+        }
+      } else {
+        return false;
+      }
+      ahead++;
+    }
+    return true;
+  }
+  consumeWhitespaceOnLine(start = 1) {
+    const maxOffset = this.maxPos - this.pos;
+    let ahead = start;
+    while (ahead < maxOffset) {
+      const code = this.lookAtCharCodeAhead(ahead);
+      if (isWhitespaceCode(code)) {
+        switch (code) {
+          case 13 /* CARRIAGE_RETURN */:
+          case 10 /* NEWLINE */:
+            this.pos += ahead;
+            return true;
+        }
+      } else {
+        this.pos += ahead;
+        return false;
+      }
+      ahead++;
+    }
+    this.pos = this.maxPos;
+    return true;
+  }
+  consumeWhitespace() {
+    const maxOffset = this.maxPos - this.pos;
+    let ahead = 0;
+    while (ahead < maxOffset && isWhitespaceCode(this.lookAtCharCodeAhead(ahead))) {
+      ahead++;
+    }
+    this.pos += ahead;
+  }
+  parse(data) {
+    const maxPos = this.maxPos = data.length;
+    this.data = data;
+    this.indent = "";
+    this.textPos = -1;
+    this.forward = 1;
+    this.isConcise = true;
+    this.beginMixedMode = this.endingMixedModeAtEOL = false;
+    this.lines = this.activeTag = this.activeAttr = void 0;
+    this.pos = data.charCodeAt(0) === 65279 ? 1 : 0;
+    this.enterState(states_exports.CONCISE_HTML_CONTENT);
+    while (this.pos < maxPos) {
+      const code = data.charCodeAt(this.pos);
+      if (code === 10 /* NEWLINE */) {
+        this.forward = 1;
+        this.activeState.eol.call(this, 1, this.activeRange);
+      } else if (code === 13 /* CARRIAGE_RETURN */ && data.charCodeAt(this.pos + 1) === 10 /* NEWLINE */) {
+        this.forward = 2;
+        this.activeState.eol.call(this, 2, this.activeRange);
+      } else {
+        this.forward = 1;
+        this.activeState.char.call(this, code, this.activeRange);
+      }
+      this.pos += this.forward;
+    }
+    while (this.pos === this.maxPos) {
+      this.forward = 1;
+      this.activeState.eof.call(this, this.activeRange);
+      if (this.forward !== 0)
+        break;
+    }
+  }
+};
+
+// src/states/index.ts
+var states_exports = {};
+__export(states_exports, {
+  ATTRIBUTE: () => ATTRIBUTE,
+  BEGIN_DELIMITED_HTML_BLOCK: () => BEGIN_DELIMITED_HTML_BLOCK,
+  CDATA: () => CDATA,
+  CLOSE_TAG: () => CLOSE_TAG,
+  CONCISE_HTML_CONTENT: () => CONCISE_HTML_CONTENT,
+  DECLARATION: () => DECLARATION,
+  DTD: () => DTD,
+  EXPRESSION: () => EXPRESSION,
+  HTML_COMMENT: () => HTML_COMMENT,
+  HTML_CONTENT: () => HTML_CONTENT,
+  INLINE_SCRIPT: () => INLINE_SCRIPT,
+  JS_COMMENT_BLOCK: () => JS_COMMENT_BLOCK,
+  JS_COMMENT_LINE: () => JS_COMMENT_LINE,
+  OPEN_TAG: () => OPEN_TAG,
+  PARSED_TEXT_CONTENT: () => PARSED_TEXT_CONTENT,
+  PLACEHOLDER: () => PLACEHOLDER,
+  REGULAR_EXPRESSION: () => REGULAR_EXPRESSION,
+  STRING: () => STRING,
+  TAG_NAME: () => TAG_NAME,
+  TEMPLATE_STRING: () => TEMPLATE_STRING,
+  checkForCDATA: () => checkForCDATA,
+  checkForClosingTag: () => checkForClosingTag,
+  checkForPlaceholder: () => checkForPlaceholder,
+  handleDelimitedEOL: () => handleDelimitedEOL
+});
+
+// src/states/ATTRIBUTE.ts
+var HTML_VALUE_TERMINATORS = [
+  62 /* CLOSE_ANGLE_BRACKET */,
+  44 /* COMMA */,
+  [47 /* FORWARD_SLASH */, 62 /* CLOSE_ANGLE_BRACKET */]
+];
+var CONCISE_VALUE_TERMINATORS = [
+  93 /* CLOSE_SQUARE_BRACKET */,
+  59 /* SEMICOLON */,
+  44 /* COMMA */
+];
+var HTML_NAME_TERMINATORS = [
+  62 /* CLOSE_ANGLE_BRACKET */,
+  44 /* COMMA */,
+  40 /* OPEN_PAREN */,
+  61 /* EQUAL */,
+  [58 /* COLON */, 61 /* EQUAL */],
+  [47 /* FORWARD_SLASH */, 62 /* CLOSE_ANGLE_BRACKET */]
+];
+var CONCISE_NAME_TERMINATORS = [
+  93 /* CLOSE_SQUARE_BRACKET */,
+  59 /* SEMICOLON */,
+  61 /* EQUAL */,
+  44 /* COMMA */,
+  40 /* OPEN_PAREN */,
+  [58 /* COLON */, 61 /* EQUAL */]
+];
+var ATTRIBUTE = {
+  name: "ATTRIBUTE",
+  enter(parent, start) {
+    return this.activeAttr = {
+      state: ATTRIBUTE,
+      parent,
+      start,
+      end: start,
+      valueStart: start,
+      stage: 0 /* UNKNOWN */,
+      name: void 0,
+      args: false,
+      bound: false,
+      spread: false
+    };
+  },
+  exit() {
+    this.activeAttr = void 0;
+  },
+  char(code, attr) {
+    if (isWhitespaceCode(code)) {
+      return;
+    } else if (code === 61 /* EQUAL */ || code === 58 /* COLON */ && this.lookAtCharCodeAhead(1) === 61 /* EQUAL */ || code === 46 /* PERIOD */ && this.lookAheadFor("..")) {
+      attr.valueStart = this.pos;
+      if (code === 58 /* COLON */) {
+        ensureAttrName(this, attr);
+        attr.bound = true;
+        this.pos += 2;
+        this.consumeWhitespace();
+      } else if (code === 46 /* PERIOD */) {
+        attr.spread = true;
+        this.pos += 3;
+      } else {
+        ensureAttrName(this, attr);
+        this.pos++;
+        this.consumeWhitespace();
+      }
+      attr.stage = 2 /* VALUE */;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminatedByWhitespace = true;
+      expr.terminator = this.isConcise ? CONCISE_VALUE_TERMINATORS : HTML_VALUE_TERMINATORS;
+      this.pos--;
+    } else if (code === 40 /* OPEN_PAREN */) {
+      ensureAttrName(this, attr);
+      attr.stage = 3 /* ARGUMENT */;
+      this.pos++;
+      this.enterState(states_exports.EXPRESSION).terminator = 41 /* CLOSE_PAREN */;
+      this.pos--;
+    } else if (code === 123 /* OPEN_CURLY_BRACE */ && attr.args) {
+      ensureAttrName(this, attr);
+      attr.stage = 4 /* BLOCK */;
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminatedByWhitespace = false;
+      expr.terminator = 125 /* CLOSE_CURLY_BRACE */;
+      this.pos--;
+    } else if (attr.stage === 0 /* UNKNOWN */) {
+      attr.stage = 1 /* NAME */;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminatedByWhitespace = true;
+      expr.skipOperators = true;
+      expr.terminator = this.isConcise ? CONCISE_NAME_TERMINATORS : HTML_NAME_TERMINATORS;
+      this.pos--;
+    } else {
+      this.exitState();
+    }
+  },
+  eol() {
+    if (this.isConcise) {
+      this.exitState();
+    }
+  },
+  eof(attr) {
+    if (this.isConcise) {
+      this.exitState();
+    } else {
+      this.emitError(attr, "MALFORMED_OPEN_TAG", 'EOF reached while parsing attribute "' + (attr.name ? this.read(attr.name) : "default") + '" for the "' + this.read(this.activeTag.tagName) + '" tag');
+    }
+  },
+  return(child, attr) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    switch (attr.stage) {
+      case 1 /* NAME */: {
+        attr.name = {
+          start: child.start,
+          end: child.end
+        };
+        (_b = (_a = this.handlers).onAttrName) == null ? void 0 : _b.call(_a, attr.name);
+        break;
+      }
+      case 3 /* ARGUMENT */: {
+        if (attr.args) {
+          this.emitError(child, "ILLEGAL_ATTRIBUTE_ARGUMENT", "An attribute can only have one set of arguments");
+          return;
+        }
+        const start = child.start - 1;
+        const end = ++this.pos;
+        const value = {
+          start: child.start,
+          end: child.end
+        };
+        if (this.consumeWhitespaceIfBefore("{")) {
+          attr.args = {
+            start,
+            end,
+            value
+          };
+        } else {
+          attr.args = true;
+          (_d = (_c = this.handlers).onAttrArgs) == null ? void 0 : _d.call(_c, {
+            start,
+            end,
+            value
+          });
+        }
+        break;
+      }
+      case 4 /* BLOCK */: {
+        const params = attr.args;
+        const start = params.start;
+        const end = ++this.pos;
+        (_f = (_e = this.handlers).onAttrMethod) == null ? void 0 : _f.call(_e, {
+          start,
+          end,
+          params,
+          body: {
+            start: child.start - 1,
+            end,
+            value: {
+              start: child.start,
+              end: child.end
+            }
+          }
+        });
+        this.exitState();
+        break;
+      }
+      case 2 /* VALUE */: {
+        if (child.start === child.end) {
+          return this.emitError(child, "ILLEGAL_ATTRIBUTE_VALUE", "Missing value for attribute");
+        }
+        if (attr.spread) {
+          (_h = (_g = this.handlers).onAttrSpread) == null ? void 0 : _h.call(_g, {
+            start: attr.valueStart,
+            end: child.end,
+            value: {
+              start: child.start,
+              end: child.end
+            }
+          });
+        } else {
+          (_j = (_i = this.handlers).onAttrValue) == null ? void 0 : _j.call(_i, {
+            start: attr.valueStart,
+            end: child.end,
+            bound: attr.bound,
+            value: {
+              start: child.start,
+              end: child.end
+            }
+          });
+        }
+        this.exitState();
+        break;
+      }
+    }
+  }
+};
+function ensureAttrName(parser, attr) {
+  var _a, _b;
+  if (!attr.name) {
+    (_b = (_a = parser.handlers).onAttrName) == null ? void 0 : _b.call(_a, {
+      start: attr.start,
+      end: attr.start
+    });
+  }
+}
+
+// src/states/BEGIN_DELIMITED_HTML_BLOCK.ts
+var BEGIN_DELIMITED_HTML_BLOCK = {
+  name: "BEGIN_DELIMITED_HTML_BLOCK",
+  enter(parent, start) {
+    return {
+      state: BEGIN_DELIMITED_HTML_BLOCK,
+      parent,
+      start,
+      end: start,
+      indent: this.indent,
+      delimiter: ""
+    };
+  },
+  exit() {
+  },
+  char(code, block) {
+    if (code === 45 /* HTML_BLOCK_DELIMITER */) {
+      block.delimiter += "-";
+    } else {
+      const startPos = this.pos;
+      if (!this.consumeWhitespaceOnLine()) {
+        this.pos = startPos + 1;
+        this.beginHtmlBlock(void 0, true);
+        this.pos--;
+      }
+    }
+  },
+  eol(len, block) {
+    this.beginHtmlBlock(block.delimiter, false);
+    handleDelimitedBlockEOL(this, len, block);
+  },
+  eof: htmlEOF,
+  return() {
+  }
+};
+function handleDelimitedEOL(parser, newLineLength, content) {
+  if (content.singleLine) {
+    parser.endText();
+    parser.exitState();
+    parser.exitState();
+    return true;
+  }
+  if (content.delimiter) {
+    handleDelimitedBlockEOL(parser, newLineLength, content);
+    return true;
+  }
+  return false;
+}
+function handleDelimitedBlockEOL(parser, newLineLength, {
+  indent,
+  delimiter
+}) {
+  const endHtmlBlockLookahead = indent + delimiter;
+  if (parser.lookAheadFor(endHtmlBlockLookahead, parser.pos + newLineLength)) {
+    parser.startText();
+    parser.pos += newLineLength;
+    parser.endText();
+    parser.pos += endHtmlBlockLookahead.length;
+    if (parser.consumeWhitespaceOnLine(0)) {
+      parser.endText();
+      parser.exitState();
+      parser.exitState();
+    } else {
+      parser.emitError(parser.pos, "INVALID_CHARACTER", "A concise mode closing block delimiter can only be followed by whitespace.");
+    }
+  } else if (parser.lookAheadFor(indent, parser.pos + newLineLength)) {
+    parser.startText();
+    parser.pos += indent.length;
+  } else if (indent && !parser.onlyWhitespaceRemainsOnLine(newLineLength)) {
+    parser.endText();
+    parser.exitState();
+    parser.exitState();
+  } else {
+    parser.startText();
+  }
+}
+
+// src/states/CDATA.ts
+var CDATA = {
+  name: "CDATA",
+  enter(parent, start) {
+    return {
+      state: CDATA,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit(cdata) {
+    var _a, _b;
+    (_b = (_a = this.handlers).onCDATA) == null ? void 0 : _b.call(_a, {
+      start: cdata.start,
+      end: cdata.end,
+      value: {
+        start: cdata.start + 9,
+        end: cdata.end - 3
+      }
+    });
+  },
+  char(code) {
+    if (code === 93 /* CLOSE_SQUARE_BRACKET */ && this.lookAheadFor("]>")) {
+      this.pos += 3;
+      this.exitState();
+      return;
+    }
+  },
+  eol() {
+  },
+  eof(cdata) {
+    this.emitError(cdata, "MALFORMED_CDATA", "EOF reached while parsing CDATA");
+  },
+  return() {
+  }
+};
+function checkForCDATA(parser) {
+  if (parser.lookAheadFor("![CDATA[")) {
+    parser.endText();
+    parser.enterState(CDATA);
+    parser.pos += 8;
+    return true;
+  }
+  return false;
+}
+
+// src/states/CLOSE_TAG.ts
+var CLOSE_TAG = {
+  name: "CLOSE_TAG",
+  enter(parent, start) {
+    this.endText();
+    return {
+      state: CLOSE_TAG,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code, closeTag) {
+    if (code === 62 /* CLOSE_ANGLE_BRACKET */) {
+      this.pos++;
+      this.exitState();
+      ensureExpectedCloseTag(this, closeTag);
+    }
+  },
+  eol() {
+  },
+  eof(closeTag) {
+    this.emitError(closeTag, "MALFORMED_CLOSE_TAG", "EOF reached while parsing closing tag");
+  },
+  return() {
+  }
+};
+function checkForClosingTag(parser) {
+  const curPos = parser.pos + 1;
+  let match = !!parser.lookAheadFor("/>");
+  let skip = 3;
+  if (!match) {
+    const { tagName } = parser.activeTag;
+    const tagNameLen = tagName.end - tagName.start;
+    if (tagNameLen) {
+      skip += tagNameLen;
+      match = parser.lookAheadFor("/", curPos) && parser.lookAheadFor(">", 1 + curPos + tagNameLen) && parser.matchAtPos(tagName, {
+        start: 1 + curPos,
+        end: 1 + curPos + tagNameLen
+      }) || false;
+    }
+  }
+  if (match) {
+    parser.endText();
+    if (ensureExpectedCloseTag(parser, {
+      start: parser.pos,
+      end: parser.pos += skip
+    })) {
+      parser.exitState();
+    }
+    return true;
+  }
+  return false;
+}
+function ensureExpectedCloseTag(parser, closeTag) {
+  const activeTag = parser.activeTag;
+  const closeTagNameStart = closeTag.start + 2;
+  const closeTagNameEnd = closeTag.end - 1;
+  if (!activeTag) {
+    parser.emitError(closeTag, "EXTRA_CLOSING_TAG", 'The closing "' + parser.read({ start: closeTagNameStart, end: closeTagNameEnd }) + '" tag was not expected');
+    return false;
+  }
+  const closeTagNamePos = {
+    start: closeTagNameStart,
+    end: closeTagNameEnd
+  };
+  if (closeTagNameStart < closeTagNameEnd) {
+    if (!parser.matchAtPos(closeTagNamePos, activeTag.tagName.end > activeTag.tagName.start ? activeTag.tagName : "div")) {
+      if (activeTag.shorthandEnd === void 0 || !parser.matchAtPos(closeTagNamePos, {
+        start: activeTag.tagName.start,
+        end: activeTag.shorthandEnd
+      })) {
+        parser.emitError(closeTag, "MISMATCHED_CLOSING_TAG", 'The closing "' + parser.read(closeTagNamePos) + '" tag does not match the corresponding opening "' + (parser.read(activeTag.tagName) || "div") + '" tag');
+        return false;
+      }
+    }
+  }
+  parser.closeTag(closeTag.start, closeTag.end, closeTagNamePos);
+  return true;
+}
+
+// src/states/CONCISE_HTML_CONTENT.ts
+var CONCISE_HTML_CONTENT = {
+  name: "CONCISE_HTML_CONTENT",
+  enter(parent, start) {
+    this.isConcise = true;
+    this.indent = "";
+    return {
+      state: CONCISE_HTML_CONTENT,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    if (isWhitespaceCode(code)) {
+      this.indent += this.data[this.pos];
+    } else {
+      const curIndent = this.indent.length;
+      const indentStart = this.pos - curIndent - 1;
+      let parentTag = this.activeTag;
+      while (parentTag && parentTag.indent.length >= curIndent) {
+        this.closeTag(indentStart, indentStart, void 0);
+        parentTag = this.activeTag;
+      }
+      if (!parentTag && curIndent) {
+        this.emitError(this.pos, "BAD_INDENTATION", "Line has extra indentation at the beginning");
+        return;
+      }
+      if (parentTag) {
+        if (parentTag.ending !== 0 /* tag */) {
+          this.emitError(this.pos, "INVALID_BODY", `The "${this.read(parentTag.tagName)}" tag does not allow nested body content`);
+          return;
+        }
+        if (parentTag.bodyMode === 1 /* PARSED_TEXT */ && code !== 45 /* HTML_BLOCK_DELIMITER */) {
+          this.emitError(this.pos, "ILLEGAL_LINE_START", 'A line within a tag that only allows text content must begin with a "-" character');
+          return;
+        }
+        if (parentTag.nestedIndent === void 0) {
+          parentTag.nestedIndent = this.indent;
+        } else if (parentTag.nestedIndent !== this.indent) {
+          this.emitError(this.pos, "BAD_INDENTATION", "Line indentation does match indentation of previous line");
+          return;
+        }
+      }
+      switch (code) {
+        case 60 /* OPEN_ANGLE_BRACKET */:
+          this.beginMixedMode = true;
+          this.pos--;
+          this.beginHtmlBlock(void 0, false);
+          return;
+        case 36 /* DOLLAR */:
+          if (isWhitespaceCode(this.lookAtCharCodeAhead(1))) {
+            this.pos++;
+            this.enterState(states_exports.INLINE_SCRIPT);
+            return;
+          }
+          break;
+        case 45 /* HTML_BLOCK_DELIMITER */:
+          if (this.lookAtCharCodeAhead(1) === 45 /* HTML_BLOCK_DELIMITER */) {
+            this.enterState(states_exports.BEGIN_DELIMITED_HTML_BLOCK);
+            this.pos--;
+          } else {
+            this.emitError(this.pos, "ILLEGAL_LINE_START", 'A line in concise mode cannot start with a single hyphen. Use "--" instead. See: https://github.com/marko-js/htmljs-parser/issues/43');
+          }
+          return;
+        case 47 /* FORWARD_SLASH */:
+          switch (this.lookAtCharCodeAhead(1)) {
+            case 47 /* FORWARD_SLASH */:
+              this.enterState(states_exports.JS_COMMENT_LINE);
+              this.pos++;
+              return;
+            case 42 /* ASTERISK */:
+              this.enterState(states_exports.JS_COMMENT_BLOCK);
+              this.pos++;
+              return;
+            default:
+              this.emitError(this.pos, "ILLEGAL_LINE_START", 'A line in concise mode cannot start with "/" unless it starts a "//" or "/*" comment');
+              return;
+          }
+      }
+      this.enterState(states_exports.OPEN_TAG);
+      this.pos--;
+    }
+  },
+  eol() {
+    this.indent = "";
+  },
+  eof: htmlEOF,
+  return(child) {
+    var _a, _b, _c, _d;
+    this.indent = "";
+    this.isConcise = true;
+    switch (child.state) {
+      case states_exports.JS_COMMENT_LINE:
+        (_b = (_a = this.handlers).onComment) == null ? void 0 : _b.call(_a, {
+          start: child.start,
+          end: child.end,
+          value: {
+            start: child.start + 2,
+            end: child.end
+          }
+        });
+        break;
+      case states_exports.JS_COMMENT_BLOCK: {
+        (_d = (_c = this.handlers).onComment) == null ? void 0 : _d.call(_c, {
+          start: child.start,
+          end: child.end,
+          value: {
+            start: child.start + 2,
+            end: child.end - 2
+          }
+        });
+        if (!this.consumeWhitespaceOnLine(0)) {
+          this.emitError(this.pos, "INVALID_CHARACTER", "In concise mode a javascript comment block can only be followed by whitespace characters and a newline.");
+        }
+        break;
+      }
+    }
+  }
+};
+
+// src/states/DECLARATION.ts
+var DECLARATION = {
+  name: "DECLARATION",
+  enter(parent, start) {
+    this.endText();
+    return {
+      state: DECLARATION,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code, declaration) {
+    if (code === 63 /* QUESTION */) {
+      if (this.lookAtCharCodeAhead(1) === 62 /* CLOSE_ANGLE_BRACKET */) {
+        exitDeclaration(this, declaration, 2);
+      }
+    } else if (code === 62 /* CLOSE_ANGLE_BRACKET */) {
+      exitDeclaration(this, declaration, 1);
+    }
+  },
+  eol() {
+  },
+  eof(declaration) {
+    this.emitError(declaration, "MALFORMED_DECLARATION", "EOF reached while parsing declaration");
+  },
+  return() {
+  }
+};
+function exitDeclaration(parser, declaration, closeOffset) {
+  var _a, _b;
+  parser.pos += closeOffset;
+  parser.exitState();
+  (_b = (_a = parser.handlers).onDeclaration) == null ? void 0 : _b.call(_a, {
+    start: declaration.start,
+    end: declaration.end,
+    value: {
+      start: declaration.start + 2,
+      end: declaration.end - closeOffset
+    }
+  });
+}
+
+// src/states/DTD.ts
+var DTD = {
+  name: "DTD",
+  enter(parent, start) {
+    this.endText();
+    return {
+      state: DTD,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit(documentType) {
+    var _a, _b;
+    (_b = (_a = this.handlers).onDoctype) == null ? void 0 : _b.call(_a, {
+      start: documentType.start,
+      end: documentType.end,
+      value: {
+        start: documentType.start + 2,
+        end: documentType.end - 1
+      }
+    });
+  },
+  char(code) {
+    if (code === 62 /* CLOSE_ANGLE_BRACKET */) {
+      this.pos++;
+      this.exitState();
+    }
+  },
+  eol() {
+  },
+  eof(documentType) {
+    this.emitError(documentType, "MALFORMED_DOCUMENT_TYPE", "EOF reached while parsing document type");
+  },
+  return() {
+  }
+};
+
+// src/states/EXPRESSION.ts
+var conciseOperatorPattern = buildOperatorPattern(true);
+var htmlOperatorPattern = buildOperatorPattern(false);
+var EXPRESSION = {
+  name: "EXPRESSION",
+  enter(parent, start) {
+    return {
+      state: EXPRESSION,
+      parent,
+      start,
+      end: start,
+      groupStack: [],
+      terminator: -1,
+      skipOperators: false,
+      terminatedByEOL: false,
+      terminatedByWhitespace: false
+    };
+  },
+  exit() {
+  },
+  char(code, expression) {
+    if (!expression.groupStack.length) {
+      if (expression.terminatedByWhitespace && isWhitespaceCode(code)) {
+        if (!checkForOperators(this, expression)) {
+          this.exitState();
+        }
+        return;
+      }
+      if (typeof expression.terminator === "number" ? expression.terminator === code : checkForTerminators(this, code, expression.terminator)) {
+        this.exitState();
+        return;
+      }
+    }
+    switch (code) {
+      case 34 /* DOUBLE_QUOTE */:
+        this.enterState(states_exports.STRING);
+        break;
+      case 39 /* SINGLE_QUOTE */:
+        this.enterState(states_exports.STRING).quoteCharCode = code;
+        break;
+      case 96 /* BACKTICK */:
+        this.enterState(states_exports.TEMPLATE_STRING);
+        break;
+      case 47 /* FORWARD_SLASH */:
+        switch (this.lookAtCharCodeAhead(1)) {
+          case 47 /* FORWARD_SLASH */:
+            this.enterState(states_exports.JS_COMMENT_LINE);
+            this.pos++;
+            break;
+          case 42 /* ASTERISK */:
+            this.enterState(states_exports.JS_COMMENT_BLOCK);
+            this.pos++;
+            break;
+          default: {
+            if (!canCharCodeBeFollowedByDivision(this.getPreviousNonWhitespaceCharCode())) {
+              this.enterState(states_exports.REGULAR_EXPRESSION);
+            }
+            break;
+          }
+        }
+        break;
+      case 40 /* OPEN_PAREN */:
+        expression.groupStack.push(41 /* CLOSE_PAREN */);
+        break;
+      case 91 /* OPEN_SQUARE_BRACKET */:
+        expression.groupStack.push(93 /* CLOSE_SQUARE_BRACKET */);
+        break;
+      case 123 /* OPEN_CURLY_BRACE */:
+        expression.groupStack.push(125 /* CLOSE_CURLY_BRACE */);
+        break;
+      case 41 /* CLOSE_PAREN */:
+      case 93 /* CLOSE_SQUARE_BRACKET */:
+      case 125 /* CLOSE_CURLY_BRACE */: {
+        if (!expression.groupStack.length) {
+          return this.emitError(expression, "INVALID_EXPRESSION", 'Mismatched group. A closing "' + String.fromCharCode(code) + '" character was found but it is not matched with a corresponding opening character.');
+        }
+        const expectedCode = expression.groupStack.pop();
+        if (expectedCode !== code) {
+          return this.emitError(expression, "INVALID_EXPRESSION", 'Mismatched group. A "' + String.fromCharCode(code) + '" character was found when "' + String.fromCharCode(expectedCode) + '" was expected.');
+        }
+        break;
+      }
+    }
+  },
+  eol(_, expression) {
+    if (!expression.groupStack.length && (expression.terminatedByWhitespace || expression.terminatedByEOL)) {
+      this.exitState();
+    }
+  },
+  eof(expression) {
+    if (!expression.groupStack.length && (this.isConcise || expression.terminatedByEOL)) {
+      this.exitState();
+    } else {
+      const { parent } = expression;
+      switch (parent.state) {
+        case states_exports.ATTRIBUTE: {
+          const attr = parent;
+          if (!attr.spread && !attr.name) {
+            return this.emitError(expression, "MALFORMED_OPEN_TAG", 'EOF reached while parsing attribute name for the "' + this.read(this.activeTag.tagName) + '" tag');
+          }
+          return this.emitError(expression, "MALFORMED_OPEN_TAG", `EOF reached while parsing attribute value for the ${attr.spread ? "..." : attr.name ? `"${this.read(attr.name)}"` : `"default"`} attribute`);
+        }
+        case states_exports.TAG_NAME:
+          return this.emitError(expression, "MALFORMED_OPEN_TAG", "EOF reached while parsing tag name");
+        case states_exports.PLACEHOLDER:
+          return this.emitError(expression, "MALFORMED_PLACEHOLDER", "EOF reached while parsing placeholder");
+      }
+      return this.emitError(expression, "INVALID_EXPRESSION", "EOF reached while parsing expression");
+    }
+  },
+  return() {
+  }
+};
+function buildOperatorPattern(isConcise) {
+  const binary = `[!~*%&^|?:]+|(?<=[!=<>&^~|/*?%+-])=|=(?=[!=<>&^~|/*?%+-])|(?<!\\+)\\s*\\+(?:\\s*\\+\\s*\\+)*\\s*(?!\\+)|(?<!-)${isConcise ? "-" : "\\s*-(?:\\s*-\\s*-)*\\s*"}(?!-)|(?<![/*])/(?![/*${isConcise ? "" : ">"}])|(?<!${isConcise ? "^\\s*|" : ""}\\.)\\.(?!\\.)|<${isConcise ? "{2,}|(?<!^\\s*)<" : "+"}|>${isConcise ? "+" : "{2,}"}|\\bin(?:stanceof)?(?=\\s+[^=/,;:>])`;
+  const unary = "\\b(?:a(?:sync|wait)|class|function|new|typeof|void)\\b";
+  const lookAheadPattern = "\\s*(?:" + binary + `)\\s*|\\s+(?=[${isConcise ? "" : "["}{(])`;
+  const lookBehindPattern = `(?<=${unary}|${binary})`;
+  return new RegExp(`${lookAheadPattern}|${lookBehindPattern}`, "ym");
+}
+function checkForOperators(parser, expression) {
+  if (expression.skipOperators) {
+    return false;
+  }
+  const pattern = parser.isConcise ? conciseOperatorPattern : htmlOperatorPattern;
+  pattern.lastIndex = parser.pos;
+  const matches = pattern.exec(parser.data);
+  if (matches) {
+    const [match] = matches;
+    if (match.length === 0) {
+      parser.consumeWhitespace();
+      parser.pos--;
+    } else {
+      parser.pos += match.length - 1;
+    }
+  } else {
+    return false;
+  }
+  return true;
+}
+function checkForTerminators(parser, code, terminators) {
+  outer:
+    for (const terminator of terminators) {
+      if (typeof terminator === "number") {
+        if (code === terminator)
+          return true;
+      } else {
+        if (terminator[0] === code) {
+          for (let i = terminator.length; i-- > 1; ) {
+            if (parser.data.charCodeAt(parser.pos + i) !== terminator[i])
+              continue outer;
+          }
+          return true;
+        }
+      }
+    }
+}
+function canCharCodeBeFollowedByDivision(code) {
+  return code >= 48 /* NUMBER_0 */ && code <= 57 /* NUMBER_9 */ || code >= 65 /* UPPER_A */ && code <= 90 /* UPPER_Z */ || code >= 97 /* LOWER_A */ && code <= 122 /* LOWER_Z */ || code === 37 /* PERCENT */ || code === 41 /* CLOSE_PAREN */ || code === 46 /* PERIOD */ || code === 60 /* OPEN_ANGLE_BRACKET */ || code === 93 /* CLOSE_SQUARE_BRACKET */ || code === 125 /* CLOSE_CURLY_BRACE */;
+}
+
+// src/states/HTML_COMMENT.ts
+var HTML_COMMENT = {
+  name: "HTML_COMMENT",
+  enter(parent, start) {
+    this.endText();
+    return {
+      state: HTML_COMMENT,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit(comment) {
+    var _a, _b;
+    (_b = (_a = this.handlers).onComment) == null ? void 0 : _b.call(_a, {
+      start: comment.start,
+      end: comment.end,
+      value: {
+        start: comment.start + 4,
+        end: comment.end - 3
+      }
+    });
+  },
+  char(code) {
+    if (code === 45 /* HYPHEN */) {
+      let offset = 1;
+      let next;
+      while ((next = this.lookAtCharCodeAhead(offset++)) === 45 /* HYPHEN */)
+        ;
+      this.pos += offset;
+      if (next === 62 /* CLOSE_ANGLE_BRACKET */) {
+        this.exitState();
+      }
+    }
+  },
+  eol() {
+  },
+  eof(comment) {
+    this.emitError(comment, "MALFORMED_COMMENT", "EOF reached while parsing comment");
+  },
+  return() {
+  }
+};
+
+// src/states/HTML_CONTENT.ts
+var HTML_CONTENT = {
+  name: "HTML_CONTENT",
+  enter(parent, start) {
+    this.isConcise = false;
+    return {
+      state: HTML_CONTENT,
+      parent,
+      start,
+      end: start,
+      indent: "",
+      singleLine: false,
+      delimiter: void 0
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    if (code === 60 /* OPEN_ANGLE_BRACKET */) {
+      if (states_exports.checkForCDATA(this))
+        return;
+      const nextCode = this.lookAtCharCodeAhead(1);
+      if (nextCode === 33 /* EXCLAMATION */) {
+        if (this.lookAtCharCodeAhead(2) === 45 /* HYPHEN */ && this.lookAtCharCodeAhead(3) === 45 /* HYPHEN */) {
+          this.enterState(states_exports.HTML_COMMENT);
+          this.pos += 3;
+        } else {
+          this.enterState(states_exports.DTD);
+          this.pos++;
+        }
+      } else if (nextCode === 63 /* QUESTION */) {
+        this.enterState(states_exports.DECLARATION);
+        this.pos++;
+      } else if (nextCode === 47 /* FORWARD_SLASH */) {
+        this.enterState(states_exports.CLOSE_TAG);
+        this.pos++;
+      } else if (nextCode === 62 /* CLOSE_ANGLE_BRACKET */ || nextCode === 60 /* OPEN_ANGLE_BRACKET */ || isWhitespaceCode(nextCode)) {
+        this.startText();
+      } else {
+        this.enterState(states_exports.OPEN_TAG);
+      }
+    } else if (code === 36 /* DOLLAR */ && isWhitespaceCode(this.lookAtCharCodeAhead(1)) && isBeginningOfLine(this)) {
+      this.endText();
+      this.enterState(states_exports.INLINE_SCRIPT);
+      this.pos++;
+    } else if (!states_exports.checkForPlaceholder(this, code)) {
+      this.startText();
+    }
+  },
+  eol(len, content) {
+    if (this.beginMixedMode) {
+      this.beginMixedMode = false;
+      this.endText();
+      this.exitState();
+    } else if (this.endingMixedModeAtEOL) {
+      this.endingMixedModeAtEOL = false;
+      this.endText();
+      this.exitState();
+    } else if (!states_exports.handleDelimitedEOL(this, len, content)) {
+      this.startText();
+    }
+  },
+  eof: htmlEOF,
+  return() {
+  }
+};
+function isBeginningOfLine(parser) {
+  let pos = parser.pos;
+  do {
+    const code = parser.data.charCodeAt(--pos);
+    if (isWhitespaceCode(code)) {
+      if (code === 10 /* NEWLINE */) {
+        return true;
+      }
+    } else {
+      return false;
+    }
+  } while (pos > 0);
+  return true;
+}
+
+// src/states/INLINE_SCRIPT.ts
+var INLINE_SCRIPT = {
+  name: "INLINE_SCRIPT",
+  enter(parent, start) {
+    this.endText();
+    return {
+      state: INLINE_SCRIPT,
+      parent,
+      start,
+      end: start,
+      block: false,
+      value: {
+        start,
+        end: start
+      }
+    };
+  },
+  exit(inlineScript) {
+    var _a, _b;
+    (_b = (_a = this.handlers).onScriptlet) == null ? void 0 : _b.call(_a, {
+      start: inlineScript.start,
+      end: inlineScript.end,
+      block: inlineScript.block,
+      value: {
+        start: inlineScript.value.start,
+        end: inlineScript.value.end
+      }
+    });
+  },
+  eol() {
+  },
+  eof() {
+  },
+  char(code, inlineScript) {
+    if (code === 123 /* OPEN_CURLY_BRACE */) {
+      inlineScript.block = true;
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminator = 125 /* CLOSE_CURLY_BRACE */;
+      expr.skipOperators = true;
+      this.pos--;
+    } else {
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminatedByEOL = true;
+      this.pos--;
+    }
+  },
+  return(child, inlineScript) {
+    if (inlineScript.block)
+      this.pos++;
+    inlineScript.value.start = child.start;
+    inlineScript.value.end = child.end;
+    this.exitState();
+  }
+};
+
+// src/states/JS_COMMENT_BLOCK.ts
+var JS_COMMENT_BLOCK = {
+  name: "JS_COMMENT_BLOCK",
+  enter(parent, start) {
+    return {
+      state: JS_COMMENT_BLOCK,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    if (code === 42 /* ASTERISK */ && this.lookAtCharCodeAhead(1) === 47 /* FORWARD_SLASH */) {
+      this.pos += 2;
+      this.exitState();
+    }
+  },
+  eol() {
+  },
+  eof(comment) {
+    this.emitError(comment, "MALFORMED_COMMENT", "EOF reached while parsing multi-line JavaScript comment");
+  },
+  return() {
+  }
+};
+
+// src/states/JS_COMMENT_LINE.ts
+var JS_COMMENT_LINE = {
+  name: "JS_COMMENT_LINE",
+  enter(parent, start) {
+    return {
+      state: JS_COMMENT_LINE,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    var _a;
+    if (!this.isConcise && code === 60 /* OPEN_ANGLE_BRACKET */ && ((_a = this.activeTag) == null ? void 0 : _a.bodyMode) === 1 /* PARSED_TEXT */) {
+      states_exports.checkForClosingTag(this);
+    }
+  },
+  eol() {
+    this.exitState();
+  },
+  eof() {
+    this.exitState();
+  },
+  return() {
+  }
+};
+
+// src/states/PARSED_TEXT_CONTENT.ts
+var PARSED_TEXT_CONTENT = {
+  name: "PARSED_TEXT_CONTENT",
+  enter(parent, start) {
+    return {
+      state: PARSED_TEXT_CONTENT,
+      parent,
+      start,
+      end: start,
+      indent: "",
+      singleLine: false,
+      delimiter: void 0
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    switch (code) {
+      case 60 /* OPEN_ANGLE_BRACKET */:
+        if (this.isConcise || !(states_exports.checkForClosingTag(this) || states_exports.checkForCDATA(this))) {
+          this.startText();
+        }
+        break;
+      case 47 /* FORWARD_SLASH */:
+        this.startText();
+        switch (this.lookAtCharCodeAhead(1)) {
+          case 42 /* ASTERISK */:
+            this.enterState(states_exports.JS_COMMENT_BLOCK);
+            this.pos++;
+            break;
+          case 47 /* FORWARD_SLASH */:
+            this.enterState(states_exports.JS_COMMENT_LINE);
+            this.pos++;
+            break;
+        }
+        break;
+      case 96 /* BACKTICK */:
+        this.startText();
+        this.enterState(states_exports.TEMPLATE_STRING);
+        break;
+      default:
+        if (!states_exports.checkForPlaceholder(this, code))
+          this.startText();
+        break;
+    }
+  },
+  eol(len, content) {
+    if (!states_exports.handleDelimitedEOL(this, len, content)) {
+      this.startText();
+    }
+  },
+  eof: htmlEOF,
+  return() {
+  }
+};
+
+// src/states/PLACEHOLDER.ts
+var PLACEHOLDER = {
+  name: "PLACEHOLDER",
+  enter(parent, start) {
+    return {
+      state: PLACEHOLDER,
+      parent,
+      start,
+      end: start,
+      escape: false
+    };
+  },
+  exit(placeholder) {
+    var _a, _b;
+    (_b = (_a = this.handlers).onPlaceholder) == null ? void 0 : _b.call(_a, {
+      start: placeholder.start,
+      end: placeholder.end,
+      escape: placeholder.escape,
+      value: {
+        start: placeholder.start + (placeholder.escape ? 2 : 3),
+        end: placeholder.end - 1
+      }
+    });
+  },
+  char() {
+  },
+  eol() {
+  },
+  eof() {
+  },
+  return(child) {
+    if (child.start === child.end) {
+      this.emitError(child, "PLACEHOLDER_EXPRESSION_REQUIRED", "Invalid placeholder, the expression cannot be missing");
+    }
+    this.pos++;
+    this.exitState();
+  }
+};
+function checkForPlaceholder(parser, code) {
+  let ahead = 0;
+  let curCode = code;
+  while (curCode === 92 /* BACK_SLASH */) {
+    curCode = parser.lookAtCharCodeAhead(++ahead);
+  }
+  if (curCode === 36 /* DOLLAR */) {
+    let escape = true;
+    curCode = parser.lookAtCharCodeAhead(ahead + 1);
+    if (curCode === 33 /* EXCLAMATION */) {
+      escape = false;
+      curCode = parser.lookAtCharCodeAhead(ahead + 2);
+    }
+    if (curCode === 123 /* OPEN_CURLY_BRACE */) {
+      if (ahead) {
+        const remainder = ahead % 2;
+        const extra = (ahead + remainder) / 2;
+        if (remainder) {
+          parser.endText();
+          parser.pos += extra;
+          parser.startText();
+          parser.pos += escape ? 2 : 3;
+          return true;
+        } else {
+          parser.startText();
+          parser.pos += extra;
+          parser.endText();
+          parser.pos += extra;
+        }
+      }
+      parser.endText();
+      parser.enterState(PLACEHOLDER).escape = escape;
+      parser.pos += escape ? 2 : 3;
+      parser.enterState(states_exports.EXPRESSION).terminator = 125 /* CLOSE_CURLY_BRACE */;
+      parser.pos--;
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/states/REGULAR_EXPRESSION.ts
+var REGULAR_EXPRESSION = {
+  name: "REGULAR_EXPRESSION",
+  enter(parent, start) {
+    return {
+      state: REGULAR_EXPRESSION,
+      parent,
+      start,
+      end: start,
+      isInCharSet: false
+    };
+  },
+  exit() {
+  },
+  char(code, regExp) {
+    if (code === 92 /* BACK_SLASH */) {
+      this.pos++;
+    } else if (code === 91 /* OPEN_SQUARE_BRACKET */ && regExp.isInCharSet) {
+      regExp.isInCharSet = true;
+    } else if (code === 93 /* CLOSE_SQUARE_BRACKET */ && regExp.isInCharSet) {
+      regExp.isInCharSet = false;
+    } else if (code === 47 /* FORWARD_SLASH */ && !regExp.isInCharSet) {
+      this.pos++;
+      this.exitState();
+    }
+  },
+  eol(_, regExp) {
+    this.emitError(regExp, "INVALID_REGULAR_EXPRESSION", "EOL reached while parsing regular expression");
+  },
+  eof(regExp) {
+    this.emitError(regExp, "INVALID_REGULAR_EXPRESSION", "EOF reached while parsing regular expression");
+  },
+  return() {
+  }
+};
+
+// src/states/STRING.ts
+var STRING = {
+  name: "STRING",
+  enter(parent, start) {
+    return {
+      state: STRING,
+      parent,
+      start,
+      end: start,
+      quoteCharCode: 34 /* DOUBLE_QUOTE */
+    };
+  },
+  exit() {
+  },
+  char(code, string) {
+    switch (code) {
+      case 92 /* BACK_SLASH */:
+        this.pos++;
+        break;
+      case string.quoteCharCode:
+        this.pos++;
+        this.exitState();
+        break;
+    }
+  },
+  eol() {
+  },
+  eof(string) {
+    this.emitError(string, "INVALID_STRING", "EOF reached while parsing string expression");
+  },
+  return() {
+  }
+};
+
+// src/states/TAG_NAME.ts
+var VOID_TAGS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "hr",
+  "embed",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var CODE_TAGS = ["import", "export", "static", "class"];
+var TAG_NAME = {
+  name: "TAG_NAME",
+  enter(parent, start) {
+    return {
+      state: TAG_NAME,
+      parent,
+      start,
+      end: start,
+      expressions: [],
+      quasis: [{ start, end: start }]
+    };
+  },
+  exit(tagName) {
+    var _a, _b, _c, _d, _e, _f;
+    const { start, end, quasis, expressions } = tagName;
+    const last = quasis[quasis.length - 1];
+    if (last.end < end)
+      last.end = end;
+    switch (tagName.shorthandCode) {
+      case 35 /* NUMBER_SIGN */:
+        if (this.activeTag.hasShorthandId) {
+          return this.emitError(tagName, "INVALID_TAG_SHORTHAND", "Multiple shorthand ID parts are not allowed on the same tag");
+        }
+        this.activeTag.hasShorthandId = true;
+        (_b = (_a = this.handlers).onTagShorthandId) == null ? void 0 : _b.call(_a, {
+          start,
+          end,
+          quasis,
+          expressions
+        });
+        break;
+      case 46 /* PERIOD */:
+        (_d = (_c = this.handlers).onTagShorthandClass) == null ? void 0 : _d.call(_c, {
+          start,
+          end,
+          quasis,
+          expressions
+        });
+        break;
+      default: {
+        const tag = this.activeTag;
+        tag.tagName = tagName;
+        if (tagName.expressions.length === 0) {
+          if (this.matchAnyAtPos(tagName, VOID_TAGS)) {
+            tag.ending |= 2 /* void */;
+          } else if (this.matchAnyAtPos(tagName, CODE_TAGS)) {
+            if (!tag.concise) {
+              return this.emitError(tagName, "RESERVED_TAG_NAME", `The "${this.read(tagName)}" tag is reserved and cannot be used as an HTML tag.`);
+            }
+            if (tag.parentTag) {
+              return this.emitError(tagName, "ROOT_TAG_ONLY", `"${this.read(tagName)}" can only be used at the root of the template.`);
+            }
+            tag.ending |= 4 /* code */;
+            this.enterState(states_exports.EXPRESSION).terminatedByEOL = true;
+          }
+        }
+        (_f = (_e = this.handlers).onTagName) == null ? void 0 : _f.call(_e, {
+          start,
+          end,
+          quasis,
+          expressions,
+          concise: this.isConcise
+        });
+        break;
+      }
+    }
+  },
+  char(code) {
+    if (code === 36 /* DOLLAR */ && this.lookAtCharCodeAhead(1) === 123 /* OPEN_CURLY_BRACE */) {
+      this.pos += 2;
+      this.enterState(states_exports.EXPRESSION).terminator = 125 /* CLOSE_CURLY_BRACE */;
+      this.pos--;
+    } else if (isWhitespaceCode(code) || code === 61 /* EQUAL */ || code === 58 /* COLON */ && this.lookAtCharCodeAhead(1) === 61 /* EQUAL */ || code === 40 /* OPEN_PAREN */ || code === 47 /* FORWARD_SLASH */ || code === 124 /* PIPE */ || (this.isConcise ? code === 59 /* SEMICOLON */ : code === 62 /* CLOSE_ANGLE_BRACKET */)) {
+      this.activeTag.shorthandEnd = this.pos;
+      this.exitState();
+    } else if (code === 46 /* PERIOD */ || code === 35 /* NUMBER_SIGN */) {
+      this.exitState();
+      const shorthand = this.enterState(TAG_NAME);
+      shorthand.shorthandCode = code;
+      shorthand.quasis[0].start = ++this.pos;
+    }
+  },
+  eol() {
+    this.activeTag.shorthandEnd = this.pos;
+    this.exitState();
+  },
+  eof() {
+    this.exitState();
+  },
+  return(child, tagName) {
+    if (child.terminatedByEOL)
+      return;
+    if (child.start === child.end) {
+      this.emitError(child, "PLACEHOLDER_EXPRESSION_REQUIRED", "Invalid placeholder, the expression cannot be missing");
+    }
+    const { quasis, expressions } = tagName;
+    const start = child.start - 2;
+    const end = ++this.pos;
+    const nextStart = end + 1;
+    expressions.push({
+      start,
+      end,
+      value: {
+        start: child.start,
+        end: child.end
+      }
+    });
+    quasis[quasis.length - 1].end = start;
+    quasis.push({ start: nextStart, end: nextStart });
+  }
+};
+
+// src/states/TEMPLATE_STRING.ts
+var TEMPLATE_STRING = {
+  name: "TEMPLATE_STRING",
+  enter(parent, start) {
+    return {
+      state: TEMPLATE_STRING,
+      parent,
+      start,
+      end: start
+    };
+  },
+  exit() {
+  },
+  char(code) {
+    if (code === 36 /* DOLLAR */ && this.lookAtCharCodeAhead(1) === 123 /* OPEN_CURLY_BRACE */) {
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.skipOperators = true;
+      expr.terminator = 125 /* CLOSE_CURLY_BRACE */;
+    } else {
+      if (code === 92 /* BACK_SLASH */) {
+        this.pos++;
+      } else if (code === 96 /* BACKTICK */) {
+        this.pos++;
+        this.exitState();
+      }
+    }
+  },
+  eof(templateString) {
+    this.emitError(templateString, "INVALID_TEMPLATE_STRING", "EOF reached while parsing template string expression");
+  },
+  eol() {
+  },
+  return(child) {
+    if (child.start === child.end) {
+      this.emitError(child, "PLACEHOLDER_EXPRESSION_REQUIRED", "Invalid placeholder, the expression cannot be missing");
+    }
+    this.pos++;
+  }
+};
+
+// src/states/OPEN_TAG.ts
+var PARSED_TEXT_TAGS = ["script", "style", "textarea", "html-comment"];
+var CONCISE_TAG_VAR_TERMINATORS = [
+  59 /* SEMICOLON */,
+  40 /* OPEN_PAREN */,
+  124 /* PIPE */,
+  61 /* EQUAL */,
+  [58 /* COLON */, 61 /* EQUAL */]
+];
+var HTML_TAG_VAR_TERMINATORS = [
+  62 /* CLOSE_ANGLE_BRACKET */,
+  40 /* OPEN_PAREN */,
+  124 /* PIPE */,
+  61 /* EQUAL */,
+  [58 /* COLON */, 61 /* EQUAL */],
+  [47 /* FORWARD_SLASH */, 62 /* CLOSE_ANGLE_BRACKET */]
+];
+var OPEN_TAG = {
+  name: "OPEN_TAG",
+  enter(parent, start) {
+    const tag = this.activeTag = {
+      state: OPEN_TAG,
+      parent,
+      start,
+      end: start,
+      stage: 0 /* UNKNOWN */,
+      parentTag: this.activeTag,
+      nestedIndent: void 0,
+      indent: this.indent,
+      hasShorthandId: false,
+      hasArgs: false,
+      hasAttrs: false,
+      shorthandEnd: -1,
+      tagName: void 0,
+      ending: 0 /* tag */,
+      concise: this.isConcise,
+      bodyMode: 0 /* HTML */,
+      beginMixedMode: this.beginMixedMode || this.endingMixedModeAtEOL
+    };
+    this.beginMixedMode = false;
+    this.endingMixedModeAtEOL = false;
+    this.endText();
+    return tag;
+  },
+  exit(tag) {
+    var _a, _b;
+    const { tagName, ending } = tag;
+    (_b = (_a = this.handlers).onOpenTagEnd) == null ? void 0 : _b.call(_a, {
+      start: this.pos - (this.isConcise ? 0 : ending & 1 /* self */ ? 2 : 1),
+      end: this.pos,
+      ending
+    });
+    if (!this.isConcise && ending !== 0 /* tag */) {
+      this.closeTag(this.pos, this.pos, void 0);
+    } else if (tagName.expressions.length === 0 && this.matchAnyAtPos(tagName, PARSED_TEXT_TAGS)) {
+      tag.bodyMode = 1 /* PARSED_TEXT */;
+      if (this.isConcise) {
+        this.enterState(states_exports.CONCISE_HTML_CONTENT);
+      } else {
+        this.enterState(states_exports.PARSED_TEXT_CONTENT);
+      }
+    }
+  },
+  eol(_, tag) {
+    if (this.isConcise && tag.stage !== 4 /* ATTR_GROUP */) {
+      this.exitState();
+    }
+  },
+  eof(tag) {
+    if (this.isConcise) {
+      if (tag.stage === 4 /* ATTR_GROUP */) {
+        this.emitError(tag, "MALFORMED_OPEN_TAG", 'EOF reached while within an attribute group (e.g. "[ ... ]").');
+        return;
+      }
+      this.exitState();
+    } else {
+      this.emitError(tag, "MALFORMED_OPEN_TAG", "EOF reached while parsing open tag");
+    }
+  },
+  char(code, tag) {
+    if (this.isConcise) {
+      if (code === 59 /* SEMICOLON */) {
+        this.pos++;
+        this.exitState();
+        if (!this.consumeWhitespaceOnLine(0)) {
+          switch (this.lookAtCharCodeAhead(0)) {
+            case 47 /* FORWARD_SLASH */:
+              switch (this.lookAtCharCodeAhead(1)) {
+                case 47 /* FORWARD_SLASH */:
+                  this.enterState(states_exports.JS_COMMENT_LINE);
+                  this.pos += 2;
+                  return;
+                case 42 /* ASTERISK */:
+                  this.enterState(states_exports.JS_COMMENT_BLOCK);
+                  this.pos += 2;
+                  return;
+              }
+              break;
+            case 60 /* OPEN_ANGLE_BRACKET */:
+              if (this.lookAheadFor("!--")) {
+                this.enterState(states_exports.HTML_COMMENT);
+                this.pos += 4;
+                return;
+              }
+              break;
+          }
+          this.emitError(this.pos, "INVALID_CODE_AFTER_SEMICOLON", "A semicolon indicates the end of a line. Only comments may follow it.");
+        }
+        return;
+      }
+      if (code === 45 /* HTML_BLOCK_DELIMITER */) {
+        if (this.lookAtCharCodeAhead(1) !== 45 /* HTML_BLOCK_DELIMITER */) {
+          this.emitError(tag, "MALFORMED_OPEN_TAG", '"-" not allowed as first character of attribute name');
+          return;
+        }
+        if (tag.stage === 4 /* ATTR_GROUP */) {
+          this.emitError(this.pos, "MALFORMED_OPEN_TAG", "Attribute group was not properly ended");
+          return;
+        }
+        this.exitState();
+        const maxPos = this.maxPos;
+        let curPos = this.pos + 1;
+        while (curPos < maxPos && this.data.charCodeAt(++curPos) !== 10 /* NEWLINE */)
+          ;
+        const indentStart = ++curPos;
+        while (curPos < maxPos) {
+          const nextCode = this.data.charCodeAt(curPos);
+          if (nextCode === 32 /* SPACE */ || nextCode === 9 /* TAB */) {
+            curPos++;
+          } else {
+            break;
+          }
+        }
+        const indentSize = curPos - indentStart;
+        if (indentSize > this.indent.length) {
+          this.indent = this.data.slice(indentStart, curPos);
+        }
+        this.enterState(states_exports.BEGIN_DELIMITED_HTML_BLOCK);
+        return;
+      } else if (code === 91 /* OPEN_SQUARE_BRACKET */) {
+        if (tag.stage === 4 /* ATTR_GROUP */) {
+          this.emitError(this.pos, "MALFORMED_OPEN_TAG", 'Unexpected "[" character within open tag.');
+          return;
+        }
+        tag.stage = 4 /* ATTR_GROUP */;
+        return;
+      } else if (code === 93 /* CLOSE_SQUARE_BRACKET */) {
+        if (tag.stage !== 4 /* ATTR_GROUP */) {
+          this.emitError(this.pos, "MALFORMED_OPEN_TAG", 'Unexpected "]" character within open tag.');
+          return;
+        }
+        tag.stage = 0 /* UNKNOWN */;
+        return;
+      }
+    } else if (code === 62 /* CLOSE_ANGLE_BRACKET */) {
+      this.pos++;
+      this.exitState();
+      return;
+    } else if (code === 47 /* FORWARD_SLASH */ && this.lookAtCharCodeAhead(1) === 62 /* CLOSE_ANGLE_BRACKET */) {
+      tag.ending |= 1 /* self */;
+      this.pos += 2;
+      this.exitState();
+      return;
+    }
+    if (code === 60 /* OPEN_ANGLE_BRACKET */) {
+      return this.emitError(this.pos, "ILLEGAL_ATTRIBUTE_NAME", 'Invalid attribute name. Attribute name cannot begin with the "<" character.');
+    }
+    if (code === 47 /* FORWARD_SLASH */ && this.lookAtCharCodeAhead(1) === 42 /* ASTERISK */) {
+      this.enterState(states_exports.JS_COMMENT_BLOCK);
+      this.pos++;
+      return;
+    }
+    if (isWhitespaceCode(code)) {
+    } else if (code === 44 /* COMMA */) {
+      this.pos++;
+      this.consumeWhitespace();
+      this.pos--;
+    } else if (code === 47 /* FORWARD_SLASH */ && !tag.hasAttrs) {
+      tag.stage = 1 /* VAR */;
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.skipOperators = true;
+      expr.terminatedByWhitespace = true;
+      expr.terminator = this.isConcise ? CONCISE_TAG_VAR_TERMINATORS : HTML_TAG_VAR_TERMINATORS;
+      this.pos--;
+    } else if (code === 40 /* OPEN_PAREN */ && !tag.hasAttrs) {
+      if (tag.hasArgs) {
+        this.emitError(this.pos, "ILLEGAL_TAG_ARGUMENT", "A tag can only have one argument");
+        return;
+      }
+      tag.stage = 2 /* ARGUMENT */;
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.skipOperators = true;
+      expr.terminator = 41 /* CLOSE_PAREN */;
+      this.pos--;
+    } else if (code === 124 /* PIPE */ && !tag.hasAttrs) {
+      tag.stage = 3 /* PARAMS */;
+      this.pos++;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.skipOperators = true;
+      expr.terminator = 124 /* PIPE */;
+      this.pos--;
+    } else {
+      if (tag.tagName) {
+        this.enterState(states_exports.ATTRIBUTE);
+        tag.hasAttrs = true;
+      } else {
+        this.enterState(states_exports.TAG_NAME);
+      }
+      this.pos--;
+    }
+  },
+  return(child, tag) {
+    var _a, _b, _c, _d, _e, _f;
+    switch (child.state) {
+      case states_exports.JS_COMMENT_BLOCK: {
+        break;
+      }
+      case states_exports.EXPRESSION: {
+        switch (tag.stage) {
+          case 1 /* VAR */: {
+            if (child.start === child.end) {
+              return this.emitError(child, "MISSING_TAG_VARIABLE", "A slash was found that was not followed by a variable name or lhs expression");
+            }
+            (_b = (_a = this.handlers).onTagVar) == null ? void 0 : _b.call(_a, {
+              start: child.start - 1,
+              end: child.end,
+              value: {
+                start: child.start,
+                end: child.end
+              }
+            });
+            break;
+          }
+          case 2 /* ARGUMENT */: {
+            const start = child.start - 1;
+            const end = ++this.pos;
+            const value = {
+              start: child.start,
+              end: child.end
+            };
+            if (this.consumeWhitespaceIfBefore("{")) {
+              const attr = this.enterState(states_exports.ATTRIBUTE);
+              attr.start = start;
+              attr.args = { start, end, value };
+              tag.hasAttrs = true;
+              this.pos--;
+            } else {
+              tag.hasArgs = true;
+              (_d = (_c = this.handlers).onTagArgs) == null ? void 0 : _d.call(_c, {
+                start,
+                end,
+                value
+              });
+            }
+            break;
+          }
+          case 3 /* PARAMS */: {
+            const end = ++this.pos;
+            (_f = (_e = this.handlers).onTagParams) == null ? void 0 : _f.call(_e, {
+              start: child.start - 1,
+              end,
+              value: {
+                start: child.start,
+                end: child.end
+              }
+            });
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+
+// src/index.ts
+function createParser(handlers) {
+  const parser = new Parser(handlers);
+  return {
+    parse(code) {
+      return parser.parse(code);
+    },
+    read(range) {
+      return parser.read(range);
+    },
+    positionAt(index) {
+      return parser.positionAt(index);
+    },
+    locationAt(range) {
+      return parser.locationAt(range);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenTagEnding,
+  createParser
+});