htmljs-parser 5.1.1 → 5.1.2

package/dist/index.mjs

@@ -69,10 +69,23 @@ function htmlEOF() {
     if (this.activeTag.concise) {
       this.closeTagEnd(this.pos, this.pos, void 0);
     } else {
-      return this.emitError(this.activeTag, 22 /* MISSING_END_TAG */, 'Missing ending "' + this.read(this.activeTag.tagName) + '" tag');
+      return this.emitError(
+        this.activeTag,
+        22 /* MISSING_END_TAG */,
+        'Missing ending "' + this.read(this.activeTag.tagName) + '" tag'
+      );
     }
   }
 }
+function matchesCloseParen(code) {
+  return code === 41 /* CLOSE_PAREN */;
+}
+function matchesCloseCurlyBrace(code) {
+  return code === 125 /* CLOSE_CURLY_BRACE */;
+}
+function matchesPipe(code) {
+  return code === 124 /* PIPE */;
+}
 function getPosAfterLine(lines, startLine, index) {
   let max = lines.length - 1;
   let line = startLine;
@@ -114,14 +127,25 @@ var Parser = class {
     return this.data.slice(range.start, range.end);
   }
   positionAt(offset) {
-    return getPosition(this.lines || (this.lines = getLines(this.data)), offset);
+    return getPosition(
+      this.lines || (this.lines = getLines(this.data)),
+      offset
+    );
   }
   locationAt(range) {
-    return getLocation(this.lines || (this.lines = getLines(this.data)), range.start, range.end);
+    return getLocation(
+      this.lines || (this.lines = getLines(this.data)),
+      range.start,
+      range.end
+    );
   }
   enterState(state) {
     this.activeState = state;
-    return this.activeRange = state.enter.call(this, this.activeRange, this.pos);
+    return this.activeRange = state.enter.call(
+      this,
+      this.activeRange,
+      this.pos
+    );
   }
   exitState() {
     const { activeRange, activeState } = this;
@@ -191,7 +215,9 @@ var Parser = class {
   }
   beginHtmlBlock(delimiter, singleLine) {
     var _a;
-    const content = this.enterState(((_a = this.activeTag) == null ? void 0 : _a.type) === 1 /* text */ ? states_exports.PARSED_TEXT_CONTENT : states_exports.HTML_CONTENT);
+    const content = this.enterState(
+      ((_a = this.activeTag) == null ? void 0 : _a.type) === 1 /* text */ ? states_exports.PARSED_TEXT_CONTENT : states_exports.HTML_CONTENT
+    );
     content.singleLine = singleLine;
     content.delimiter = delimiter;
     content.indent = this.indent;
@@ -351,294 +377,712 @@ __export(states_exports, {
   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",
+// src/states/OPEN_TAG.ts
+var TAG_STAGE = /* @__PURE__ */ ((TAG_STAGE2) => {
+  TAG_STAGE2[TAG_STAGE2["UNKNOWN"] = 0] = "UNKNOWN";
+  TAG_STAGE2[TAG_STAGE2["VAR"] = 1] = "VAR";
+  TAG_STAGE2[TAG_STAGE2["ARGUMENT"] = 2] = "ARGUMENT";
+  TAG_STAGE2[TAG_STAGE2["PARAMS"] = 3] = "PARAMS";
+  TAG_STAGE2[TAG_STAGE2["ATTR_GROUP"] = 4] = "ATTR_GROUP";
+  return TAG_STAGE2;
+})(TAG_STAGE || {});
+var OPEN_TAG = {
+  name: "OPEN_TAG",
   enter(parent, start) {
-    return this.activeAttr = {
-      state: ATTRIBUTE,
+    const tag = this.activeTag = {
+      state: OPEN_TAG,
+      type: 0 /* html */,
       parent,
       start,
       end: start,
-      valueStart: start,
       stage: 0 /* UNKNOWN */,
-      name: void 0,
-      args: false,
-      bound: false,
-      spread: false
+      parentTag: this.activeTag,
+      nestedIndent: void 0,
+      indent: this.indent,
+      hasShorthandId: false,
+      hasArgs: false,
+      hasAttrs: false,
+      selfClosed: false,
+      shorthandEnd: -1,
+      tagName: void 0,
+      concise: this.isConcise,
+      beginMixedMode: this.beginMixedMode || this.endingMixedModeAtEOL
     };
+    this.beginMixedMode = false;
+    this.endingMixedModeAtEOL = false;
+    this.endText();
+    return tag;
   },
-  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;
-      this.forward = 0;
-      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();
+  exit(tag) {
+    var _a, _b;
+    const { selfClosed } = tag;
+    (_b = (_a = this.options).onOpenTagEnd) == null ? void 0 : _b.call(_a, {
+      start: this.pos - (this.isConcise ? 0 : selfClosed ? 2 : 1),
+      end: this.pos,
+      selfClosed
+    });
+    switch (selfClosed ? 2 /* void */ : tag.type) {
+      case 2 /* void */:
+      case 3 /* statement */: {
+        if (tag.beginMixedMode)
+          this.endingMixedModeAtEOL = true;
+        this.activeTag = tag.parentTag;
+        break;
       }
-      attr.stage = 2 /* VALUE */;
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.terminatedByWhitespace = true;
-      expr.terminator = this.isConcise ? CONCISE_VALUE_TERMINATORS : HTML_VALUE_TERMINATORS;
-    } else if (code === 40 /* OPEN_PAREN */) {
-      ensureAttrName(this, attr);
-      attr.stage = 3 /* ARGUMENT */;
-      this.pos++;
-      this.forward = 0;
-      this.enterState(states_exports.EXPRESSION).terminator = 41 /* CLOSE_PAREN */;
-    } else if (code === 123 /* OPEN_CURLY_BRACE */ && attr.args) {
-      ensureAttrName(this, attr);
-      attr.stage = 4 /* BLOCK */;
-      this.pos++;
-      this.forward = 0;
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.terminatedByWhitespace = false;
-      expr.terminator = 125 /* CLOSE_CURLY_BRACE */;
-    } else if (attr.stage === 0 /* UNKNOWN */) {
-      attr.stage = 1 /* NAME */;
-      this.forward = 0;
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.terminatedByWhitespace = true;
-      expr.skipOperators = true;
-      expr.terminator = this.isConcise ? CONCISE_NAME_TERMINATORS : HTML_NAME_TERMINATORS;
-    } else {
-      this.exitState();
+      case 1 /* text */:
+        if (this.isConcise) {
+          this.enterState(states_exports.CONCISE_HTML_CONTENT);
+        } else {
+          this.enterState(states_exports.PARSED_TEXT_CONTENT);
+        }
+        break;
     }
   },
-  eol() {
-    if (this.isConcise) {
+  eol(_, tag) {
+    if (this.isConcise && tag.stage !== 4 /* ATTR_GROUP */) {
       this.exitState();
     }
   },
-  eof(attr) {
+  eof(tag) {
     if (this.isConcise) {
+      if (tag.stage === 4 /* ATTR_GROUP */) {
+        this.emitError(
+          tag,
+          19 /* MALFORMED_OPEN_TAG */,
+          'EOF reached while within an attribute group (e.g. "[ ... ]").'
+        );
+        return;
+      }
       this.exitState();
     } else {
-      this.emitError(attr, 19 /* MALFORMED_OPEN_TAG */, 'EOF reached while parsing attribute "' + (attr.name ? this.read(attr.name) : "default") + '" for the "' + this.read(this.activeTag.tagName) + '" tag');
+      this.emitError(
+        tag,
+        19 /* MALFORMED_OPEN_TAG */,
+        "EOF reached while parsing open 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.options).onAttrName) == null ? void 0 : _b.call(_a, attr.name);
-        break;
+  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,
+            5 /* INVALID_CODE_AFTER_SEMICOLON */,
+            "A semicolon indicates the end of a line. Only comments may follow it."
+          );
+        }
+        return;
       }
-      case 3 /* ARGUMENT */: {
-        if (attr.args) {
-          this.emitError(child, 1 /* INVALID_ATTRIBUTE_ARGUMENT */, "An attribute can only have one set of arguments");
+      if (code === 45 /* HTML_BLOCK_DELIMITER */) {
+        if (this.lookAtCharCodeAhead(1) !== 45 /* HTML_BLOCK_DELIMITER */) {
+          this.emitError(
+            tag,
+            19 /* MALFORMED_OPEN_TAG */,
+            '"-" not allowed as first character of attribute name'
+          );
           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.options).onAttrArgs) == null ? void 0 : _d.call(_c, {
-            start,
-            end,
-            value
-          });
+        if (tag.stage === 4 /* ATTR_GROUP */) {
+          this.emitError(
+            this.pos,
+            19 /* MALFORMED_OPEN_TAG */,
+            "Attribute group was not properly ended"
+          );
+          return;
         }
-        break;
-      }
-      case 4 /* BLOCK */: {
-        const params = attr.args;
-        const start = params.start;
-        const end = ++this.pos;
-        (_f = (_e = this.options).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, 3 /* INVALID_ATTRIBUTE_VALUE */, "Missing value for attribute");
+        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;
+          }
         }
-        if (attr.spread) {
-          (_h = (_g = this.options).onAttrSpread) == null ? void 0 : _h.call(_g, {
-            start: attr.valueStart,
-            end: child.end,
-            value: {
-              start: child.start,
-              end: child.end
-            }
-          });
-        } else {
-          (_j = (_i = this.options).onAttrValue) == null ? void 0 : _j.call(_i, {
-            start: attr.valueStart,
-            end: child.end,
-            bound: attr.bound,
-            value: {
-              start: child.start,
-              end: child.end
-            }
-          });
+        const indentSize = curPos - indentStart;
+        if (indentSize > this.indent.length) {
+          this.indent = this.data.slice(indentStart, curPos);
         }
-        this.exitState();
-        break;
+        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,
+            19 /* 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,
+            19 /* 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.selfClosed = true;
+      this.pos += 2;
+      this.exitState();
+      return;
+    }
+    if (code === 60 /* OPEN_ANGLE_BRACKET */) {
+      return this.emitError(
+        this.pos,
+        2 /* INVALID_ATTRIBUTE_NAME */,
+        'Invalid attribute name. Attribute name cannot begin with the "<" character.'
+      );
+    }
+    if (code === 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;
+      }
+    }
+    if (isWhitespaceCode(code)) {
+    } else if (code === 44 /* COMMA */) {
+      this.pos++;
+      this.forward = 0;
+      this.consumeWhitespace();
+    } else if (code === 47 /* FORWARD_SLASH */ && !tag.hasAttrs) {
+      tag.stage = 1 /* VAR */;
+      this.pos++;
+      this.forward = 0;
+      if (isWhitespaceCode(this.lookAtCharCodeAhead(0))) {
+        return this.emitError(
+          this.pos,
+          23 /* MISSING_TAG_VARIABLE */,
+          "A slash was found that was not followed by a variable name or lhs expression"
+        );
+      }
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.operators = true;
+      expr.terminatedByWhitespace = true;
+      expr.shouldTerminate = this.isConcise ? shouldTerminateConciseTagVar : shouldTerminateHtmlTagVar;
+    } else if (code === 40 /* OPEN_PAREN */ && !tag.hasAttrs) {
+      if (tag.hasArgs) {
+        this.emitError(
+          this.pos,
+          11 /* INVALID_TAG_ARGUMENT */,
+          "A tag can only have one argument"
+        );
+        return;
+      }
+      tag.stage = 2 /* ARGUMENT */;
+      this.pos++;
+      this.forward = 0;
+      this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseParen;
+    } else if (code === 124 /* PIPE */ && !tag.hasAttrs) {
+      tag.stage = 3 /* PARAMS */;
+      this.pos++;
+      this.forward = 0;
+      this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesPipe;
+    } else {
+      this.forward = 0;
+      if (tag.tagName) {
+        this.enterState(states_exports.ATTRIBUTE);
+        tag.hasAttrs = true;
+      } else {
+        this.enterState(states_exports.TAG_NAME);
+      }
+    }
+  },
+  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,
+                23 /* MISSING_TAG_VARIABLE */,
+                "A slash was found that was not followed by a variable name or lhs expression"
+              );
+            }
+            (_b = (_a = this.options).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.forward = 0;
+            } else {
+              tag.hasArgs = true;
+              (_d = (_c = this.options).onTagArgs) == null ? void 0 : _d.call(_c, {
+                start,
+                end,
+                value
+              });
+            }
+            break;
+          }
+          case 3 /* PARAMS */: {
+            const end = ++this.pos;
+            (_f = (_e = this.options).onTagParams) == null ? void 0 : _f.call(_e, {
+              start: child.start - 1,
+              end,
+              value: {
+                start: child.start,
+                end: child.end
+              }
+            });
+            break;
+          }
+        }
+        break;
       }
     }
   }
 };
-function ensureAttrName(parser, attr) {
-  var _a, _b;
-  if (!attr.name) {
-    (_b = (_a = parser.options).onAttrName) == null ? void 0 : _b.call(_a, {
-      start: attr.start,
-      end: attr.start
-    });
+function shouldTerminateConciseTagVar(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 61 /* EQUAL */:
+    case 124 /* PIPE */:
+    case 40 /* OPEN_PAREN */:
+    case 59 /* SEMICOLON */:
+      return true;
+    case 58 /* COLON */:
+      return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
+    default:
+      return false;
+  }
+}
+function shouldTerminateHtmlTagVar(code, data, pos) {
+  switch (code) {
+    case 124 /* PIPE */:
+    case 44 /* COMMA */:
+    case 61 /* EQUAL */:
+    case 40 /* OPEN_PAREN */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+      return true;
+    case 58 /* COLON */:
+      return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
+    case 47 /* FORWARD_SLASH */:
+      return data.charCodeAt(pos + 1) === 62 /* CLOSE_ANGLE_BRACKET */;
+    default:
+      return false;
   }
 }
 
-// src/states/BEGIN_DELIMITED_HTML_BLOCK.ts
-var BEGIN_DELIMITED_HTML_BLOCK = {
-  name: "BEGIN_DELIMITED_HTML_BLOCK",
+// src/states/ATTRIBUTE.ts
+var ATTRIBUTE = {
+  name: "ATTRIBUTE",
   enter(parent, start) {
-    return {
-      state: BEGIN_DELIMITED_HTML_BLOCK,
+    return this.activeAttr = {
+      state: ATTRIBUTE,
       parent,
       start,
       end: start,
-      indent: this.indent,
-      delimiter: ""
+      valueStart: start,
+      stage: 0 /* UNKNOWN */,
+      name: void 0,
+      args: false,
+      bound: false,
+      spread: false
     };
   },
   exit() {
+    this.activeAttr = void 0;
   },
-  char(code, block) {
-    if (code === 45 /* HTML_BLOCK_DELIMITER */) {
-      block.delimiter += "-";
-    } else {
-      const startPos = this.pos;
-      if (!this.consumeWhitespaceOnLine()) {
-        this.pos = startPos + 1;
-        this.forward = 0;
-        this.beginHtmlBlock(void 0, true);
+  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;
+      this.forward = 0;
+      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.operators = true;
+      expr.terminatedByWhitespace = true;
+      expr.shouldTerminate = this.isConcise ? this.activeTag.stage === 4 /* ATTR_GROUP */ ? shouldTerminateConciseGroupedAttrValue : shouldTerminateConciseAttrValue : shouldTerminateHtmlAttrValue;
+    } else if (code === 40 /* OPEN_PAREN */) {
+      ensureAttrName(this, attr);
+      attr.stage = 3 /* ARGUMENT */;
+      this.pos++;
+      this.forward = 0;
+      this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseParen;
+    } else if (code === 123 /* OPEN_CURLY_BRACE */ && attr.args) {
+      ensureAttrName(this, attr);
+      attr.stage = 4 /* BLOCK */;
+      this.pos++;
+      this.forward = 0;
+      this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseCurlyBrace;
+    } else if (attr.stage === 0 /* UNKNOWN */) {
+      attr.stage = 1 /* NAME */;
+      this.forward = 0;
+      const expr = this.enterState(states_exports.EXPRESSION);
+      expr.terminatedByWhitespace = true;
+      expr.shouldTerminate = this.isConcise ? this.activeTag.stage === 4 /* ATTR_GROUP */ ? shouldTerminateConciseGroupedAttrName : shouldTerminateConciseAttrName : shouldTerminateHtmlAttrName;
+    } else {
+      this.exitState();
     }
   },
-  eol(len, block) {
-    this.beginHtmlBlock(block.delimiter, false);
-    handleDelimitedBlockEOL(this, len, block);
+  eol() {
+    if (this.isConcise) {
+      this.exitState();
+    }
   },
-  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();
+  eof(attr) {
+    if (this.isConcise) {
+      this.exitState();
     } else {
-      parser.emitError(parser.pos, 4 /* INVALID_CHARACTER */, "A concise mode closing block delimiter can only be followed by whitespace.");
+      this.emitError(
+        attr,
+        19 /* MALFORMED_OPEN_TAG */,
+        'EOF reached while parsing attribute "' + (attr.name ? this.read(attr.name) : "default") + '" for the "' + this.read(this.activeTag.tagName) + '" tag'
+      );
     }
-  } 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,
+  },
+  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.options).onAttrName) == null ? void 0 : _b.call(_a, attr.name);
+        break;
+      }
+      case 3 /* ARGUMENT */: {
+        if (attr.args) {
+          this.emitError(
+            child,
+            1 /* INVALID_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.options).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.options).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,
+            3 /* INVALID_ATTRIBUTE_VALUE */,
+            "Missing value for attribute"
+          );
+        }
+        if (attr.spread) {
+          (_h = (_g = this.options).onAttrSpread) == null ? void 0 : _h.call(_g, {
+            start: attr.valueStart,
+            end: child.end,
+            value: {
+              start: child.start,
+              end: child.end
+            }
+          });
+        } else {
+          (_j = (_i = this.options).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.options).onAttrName) == null ? void 0 : _b.call(_a, {
+      start: attr.start,
+      end: attr.start
+    });
+  }
+}
+function shouldTerminateHtmlAttrName(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 61 /* EQUAL */:
+    case 40 /* OPEN_PAREN */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+      return true;
+    case 58 /* COLON */:
+      return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
+    case 47 /* FORWARD_SLASH */:
+      return data.charCodeAt(pos + 1) === 62 /* CLOSE_ANGLE_BRACKET */;
+    default:
+      return false;
+  }
+}
+function shouldTerminateHtmlAttrValue(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+      return true;
+    case 47 /* FORWARD_SLASH */:
+      return data.charCodeAt(pos + 1) === 62 /* CLOSE_ANGLE_BRACKET */;
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+      return data.charCodeAt(pos - 1) !== 61 /* EQUAL */;
+    default:
+      return false;
+  }
+}
+function shouldTerminateConciseAttrName(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 61 /* EQUAL */:
+    case 40 /* OPEN_PAREN */:
+    case 59 /* SEMICOLON */:
+      return true;
+    case 58 /* COLON */:
+      return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
+    case 45 /* HYPHEN */:
+      return data.charCodeAt(pos + 1) === 45 /* HYPHEN */ && isWhitespaceCode(data.charCodeAt(pos - 1));
+    default:
+      return false;
+  }
+}
+function shouldTerminateConciseAttrValue(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 59 /* SEMICOLON */:
+      return true;
+    case 45 /* HYPHEN */:
+      return data.charCodeAt(pos + 1) === 45 /* HYPHEN */ && isWhitespaceCode(data.charCodeAt(pos - 1));
+    default:
+      return false;
+  }
+}
+function shouldTerminateConciseGroupedAttrName(code, data, pos) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 61 /* EQUAL */:
+    case 40 /* OPEN_PAREN */:
+    case 93 /* CLOSE_SQUARE_BRACKET */:
+      return true;
+    case 58 /* COLON */:
+      return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
+    default:
+      return false;
+  }
+}
+function shouldTerminateConciseGroupedAttrValue(code) {
+  switch (code) {
+    case 44 /* COMMA */:
+    case 93 /* CLOSE_SQUARE_BRACKET */:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// 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.forward = 0;
+        this.beginHtmlBlock(void 0, true);
+      }
+    }
+  },
+  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,
+        4 /* 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
     };
@@ -664,7 +1108,11 @@ var CDATA = {
   eol() {
   },
   eof(cdata) {
-    this.emitError(cdata, 14 /* MALFORMED_CDATA */, "EOF reached while parsing CDATA");
+    this.emitError(
+      cdata,
+      14 /* MALFORMED_CDATA */,
+      "EOF reached while parsing CDATA"
+    );
   },
   return() {
   }
@@ -703,7 +1151,11 @@ var CLOSE_TAG = {
   eol() {
   },
   eof(closeTag) {
-    this.emitError(closeTag, 15 /* MALFORMED_CLOSE_TAG */, "EOF reached while parsing closing tag");
+    this.emitError(
+      closeTag,
+      15 /* MALFORMED_CLOSE_TAG */,
+      "EOF reached while parsing closing tag"
+    );
   },
   return() {
   }
@@ -745,7 +1197,11 @@ function ensureExpectedCloseTag(parser, closeTag) {
   const closeTagNameStart = closeTag.start + 2;
   const closeTagNameEnd = closeTag.end - 1;
   if (!activeTag) {
-    parser.emitError(closeTag, 0 /* EXTRA_CLOSING_TAG */, 'The closing "' + parser.read({ start: closeTagNameStart, end: closeTagNameEnd }) + '" tag was not expected');
+    parser.emitError(
+      closeTag,
+      0 /* EXTRA_CLOSING_TAG */,
+      'The closing "' + parser.read({ start: closeTagNameStart, end: closeTagNameEnd }) + '" tag was not expected'
+    );
     return false;
   }
   const closeTagNamePos = {
@@ -753,12 +1209,19 @@ function ensureExpectedCloseTag(parser, closeTag) {
     end: closeTagNameEnd
   };
   if (closeTagNameStart < closeTagNameEnd) {
-    if (!parser.matchAtPos(closeTagNamePos, activeTag.tagName.end > activeTag.tagName.start ? activeTag.tagName : "div")) {
+    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, 21 /* MISMATCHED_CLOSING_TAG */, 'The closing "' + parser.read(closeTagNamePos) + '" tag does not match the corresponding opening "' + (parser.read(activeTag.tagName) || "div") + '" tag');
+        parser.emitError(
+          closeTag,
+          21 /* MISMATCHED_CLOSING_TAG */,
+          'The closing "' + parser.read(closeTagNamePos) + '" tag does not match the corresponding opening "' + (parser.read(activeTag.tagName) || "div") + '" tag'
+        );
         return false;
       }
     }
@@ -794,18 +1257,30 @@ var CONCISE_HTML_CONTENT = {
         parentTag = this.activeTag;
       }
       if (!parentTag && curIndent) {
-        this.emitError(this.pos, 7 /* INVALID_INDENTATION */, "Line has extra indentation at the beginning");
+        this.emitError(
+          this.pos,
+          7 /* INVALID_INDENTATION */,
+          "Line has extra indentation at the beginning"
+        );
         return;
       }
       if (parentTag) {
         if (parentTag.type === 1 /* text */ && code !== 45 /* HTML_BLOCK_DELIMITER */) {
-          this.emitError(this.pos, 8 /* INVALID_LINE_START */, 'A line within a tag that only allows text content must begin with a "-" character');
+          this.emitError(
+            this.pos,
+            8 /* INVALID_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, 7 /* INVALID_INDENTATION */, "Line indentation does match indentation of previous line");
+          this.emitError(
+            this.pos,
+            7 /* INVALID_INDENTATION */,
+            "Line indentation does match indentation of previous line"
+          );
           return;
         }
       }
@@ -827,7 +1302,11 @@ var CONCISE_HTML_CONTENT = {
             this.enterState(states_exports.BEGIN_DELIMITED_HTML_BLOCK);
             this.pos--;
           } else {
-            this.emitError(this.pos, 8 /* INVALID_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');
+            this.emitError(
+              this.pos,
+              8 /* INVALID_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 */:
@@ -841,7 +1320,11 @@ var CONCISE_HTML_CONTENT = {
               this.pos++;
               return;
             default:
-              this.emitError(this.pos, 8 /* INVALID_LINE_START */, 'A line in concise mode cannot start with "/" unless it starts a "//" or "/*" comment');
+              this.emitError(
+                this.pos,
+                8 /* INVALID_LINE_START */,
+                'A line in concise mode cannot start with "/" unless it starts a "//" or "/*" comment'
+              );
               return;
           }
       }
@@ -878,7 +1361,11 @@ var CONCISE_HTML_CONTENT = {
           }
         });
         if (!this.consumeWhitespaceOnLine(0)) {
-          this.emitError(this.pos, 4 /* INVALID_CHARACTER */, "In concise mode a javascript comment block can only be followed by whitespace characters and a newline.");
+          this.emitError(
+            this.pos,
+            4 /* INVALID_CHARACTER */,
+            "In concise mode a javascript comment block can only be followed by whitespace characters and a newline."
+          );
         }
         break;
       }
@@ -912,7 +1399,11 @@ var DECLARATION = {
   eol() {
   },
   eof(declaration) {
-    this.emitError(declaration, 17 /* MALFORMED_DECLARATION */, "EOF reached while parsing declaration");
+    this.emitError(
+      declaration,
+      17 /* MALFORMED_DECLARATION */,
+      "EOF reached while parsing declaration"
+    );
   },
   return() {
   }
@@ -963,16 +1454,29 @@ var DTD = {
   eol() {
   },
   eof(documentType) {
-    this.emitError(documentType, 18 /* MALFORMED_DOCUMENT_TYPE */, "EOF reached while parsing document type");
+    this.emitError(
+      documentType,
+      18 /* MALFORMED_DOCUMENT_TYPE */,
+      "EOF reached while parsing document type"
+    );
   },
   return() {
   }
 };
 
 // src/states/EXPRESSION.ts
-var htmlAttrsPattern = buildPattern(0 /* HTML_ATTRS */);
-var conciseAttrsPattern = buildPattern(1 /* CONCISE_ATTRS */);
-var conciseAttrsGroupPattern = buildPattern(2 /* CONCISE_ATTRS_GROUP */);
+var shouldTerminate = () => false;
+var unaryKeywords = [
+  "async",
+  "await",
+  "keyof",
+  "class",
+  "function",
+  "new",
+  "typeof",
+  "void"
+];
+var binaryKeywords = ["instanceof", "in", "as", "extends"];
 var EXPRESSION = {
   name: "EXPRESSION",
   enter(parent, start) {
@@ -982,8 +1486,8 @@ var EXPRESSION = {
       start,
       end: start,
       groupStack: [],
-      terminator: -1,
-      skipOperators: false,
+      shouldTerminate,
+      operators: false,
       terminatedByEOL: false,
       terminatedByWhitespace: false
     };
@@ -993,12 +1497,12 @@ var EXPRESSION = {
   char(code, expression) {
     if (!expression.groupStack.length) {
       if (expression.terminatedByWhitespace && isWhitespaceCode(code)) {
-        if (!checkForOperators(this, expression)) {
+        if (!checkForOperators(this, expression, false)) {
           this.exitState();
         }
         return;
       }
-      if (typeof expression.terminator === "number" ? expression.terminator === code : checkForTerminators(this, code, expression.terminator)) {
+      if (expression.shouldTerminate(code, this.data, this.pos)) {
         this.exitState();
         return;
       }
@@ -1024,7 +1528,7 @@ var EXPRESSION = {
             this.pos++;
             break;
           default: {
-            if (canCharCodeBeFollowedByDivision(this.getPreviousNonWhitespaceCharCode())) {
+            if (canFollowDivision(this.getPreviousNonWhitespaceCharCode())) {
               this.pos++;
               this.consumeWhitespace();
             } else {
@@ -1047,18 +1551,26 @@ var EXPRESSION = {
       case 93 /* CLOSE_SQUARE_BRACKET */:
       case 125 /* CLOSE_CURLY_BRACE */: {
         if (!expression.groupStack.length) {
-          return this.emitError(expression, 6 /* INVALID_EXPRESSION */, 'Mismatched group. A closing "' + String.fromCharCode(code) + '" character was found but it is not matched with a corresponding opening character.');
+          return this.emitError(
+            expression,
+            6 /* 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, 6 /* INVALID_EXPRESSION */, 'Mismatched group. A "' + String.fromCharCode(code) + '" character was found when "' + String.fromCharCode(expectedCode) + '" was expected.');
+          return this.emitError(
+            expression,
+            6 /* 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.terminatedByEOL || expression.terminatedByWhitespace) && !checkForOperators(this, expression)) {
+    if (!expression.groupStack.length && (expression.terminatedByEOL || expression.terminatedByWhitespace) && !checkForOperators(this, expression, true)) {
       this.exitState();
     }
   },
@@ -1071,69 +1583,216 @@ var EXPRESSION = {
         case states_exports.ATTRIBUTE: {
           const attr = parent;
           if (!attr.spread && !attr.name) {
-            return this.emitError(expression, 19 /* MALFORMED_OPEN_TAG */, 'EOF reached while parsing attribute name for the "' + this.read(this.activeTag.tagName) + '" tag');
+            return this.emitError(
+              expression,
+              19 /* MALFORMED_OPEN_TAG */,
+              'EOF reached while parsing attribute name for the "' + this.read(this.activeTag.tagName) + '" tag'
+            );
           }
-          return this.emitError(expression, 19 /* MALFORMED_OPEN_TAG */, `EOF reached while parsing attribute value for the ${attr.spread ? "..." : attr.name ? `"${this.read(attr.name)}"` : `"default"`} attribute`);
+          return this.emitError(
+            expression,
+            19 /* 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, 19 /* MALFORMED_OPEN_TAG */, "EOF reached while parsing tag name");
+          return this.emitError(
+            expression,
+            19 /* MALFORMED_OPEN_TAG */,
+            "EOF reached while parsing tag name"
+          );
         case states_exports.PLACEHOLDER:
-          return this.emitError(expression, 20 /* MALFORMED_PLACEHOLDER */, "EOF reached while parsing placeholder");
+          return this.emitError(
+            expression,
+            20 /* MALFORMED_PLACEHOLDER */,
+            "EOF reached while parsing placeholder"
+          );
       }
-      return this.emitError(expression, 6 /* INVALID_EXPRESSION */, "EOF reached while parsing expression");
+      return this.emitError(
+        expression,
+        6 /* INVALID_EXPRESSION */,
+        "EOF reached while parsing expression"
+      );
     }
   },
   return() {
   }
 };
-function buildPattern(type) {
-  const space = type === 1 /* CONCISE_ATTRS */ ? "[ \\t]" : "\\s";
-  const binary = `(?:[!~*%&^|?<]+=*)+|:+(?!=)|[>/+=-]+=|=>|(?<!\\+)[ \\t]*\\+(?:\\s*\\+\\s*\\+)*\\s*(?!\\+)|(?<!-)-${type === 1 /* CONCISE_ATTRS */ ? "" : "(?:\\s*-\\s*-)*\\s*"}(?!-)|(?<!\\.)\\.(?!\\.)|>${type === 0 /* HTML_ATTRS */ ? "{2,}" : "+"}|[ \\t]+(?:in(?:stanceof)?|as|extends)(?=[ \\t]+[^=/,;:>])`;
-  const unary = "\\b(?<![.]\\s*)(?:a(?:sync|wait)|keyof|class|function|new|typeof|void)\\b";
-  const lookAheadPattern = `${space}*(?:${binary})\\s*|${space}+(?=[{(]|/[^>])`;
-  const lookBehindPattern = `(?<=${unary}|${binary})`;
-  return new RegExp(`${lookAheadPattern}|${lookBehindPattern}`, "ym");
-}
-function checkForOperators(parser, expression) {
-  var _a;
-  if (expression.skipOperators) {
+function checkForOperators(parser, expression, eol) {
+  if (!expression.operators)
     return false;
+  const { pos, data } = parser;
+  if (lookBehindForOperator(data, pos) !== -1) {
+    parser.consumeWhitespace();
+    parser.forward = 0;
+    return true;
   }
-  const pattern = parser.isConcise ? ((_a = parser.activeTag) == null ? void 0 : _a.stage) === states_exports.TAG_STAGE.ATTR_GROUP ? conciseAttrsGroupPattern : conciseAttrsPattern : expression.terminatedByEOL ? conciseAttrsPattern : htmlAttrsPattern;
-  pattern.lastIndex = parser.pos;
-  const matches = pattern.exec(parser.data);
-  if (matches) {
-    const [match] = matches;
-    if (match.length === 0) {
-      parser.consumeWhitespace();
-    } else {
-      parser.pos += match.length;
+  const terminatedByEOL = expression.terminatedByEOL || parser.isConcise;
+  if (!(terminatedByEOL && eol)) {
+    const nextNonSpace = lookAheadWhile(
+      terminatedByEOL ? isIndentCode : isWhitespaceCode,
+      data,
+      pos + 1
+    );
+    if (!expression.shouldTerminate(
+      data.charCodeAt(nextNonSpace),
+      data,
+      nextNonSpace
+    )) {
+      const lookAheadPos = lookAheadForOperator(data, nextNonSpace);
+      if (lookAheadPos !== -1) {
+        parser.pos = lookAheadPos;
+        parser.forward = 0;
+        return true;
+      }
     }
-    parser.forward = 0;
-  } else {
-    return false;
   }
-  return true;
+  return false;
 }
-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 lookBehindForOperator(data, pos) {
+  const curPos = pos - 1;
+  const code = data.charCodeAt(curPos);
+  switch (code) {
+    case 38 /* AMPERSAND */:
+    case 42 /* ASTERISK */:
+    case 94 /* CARET */:
+    case 58 /* COLON */:
+    case 61 /* EQUAL */:
+    case 33 /* EXCLAMATION */:
+    case 60 /* OPEN_ANGLE_BRACKET */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+    case 37 /* PERCENT */:
+    case 46 /* PERIOD */:
+    case 124 /* PIPE */:
+    case 63 /* QUESTION */:
+    case 126 /* TILDE */:
+      return curPos;
+    case 43 /* PLUS */:
+    case 45 /* HYPHEN */: {
+      if (data.charCodeAt(curPos - 1) === code) {
+        return lookBehindForOperator(
+          data,
+          lookBehindWhile(isWhitespaceCode, data, curPos - 2)
+        );
+      }
+      return curPos;
+    }
+    default: {
+      for (const keyword of unaryKeywords) {
+        const keywordPos = lookBehindFor(data, curPos, keyword);
+        if (keywordPos !== -1) {
+          return data.charCodeAt(keywordPos - 1) === 46 /* PERIOD */ ? -1 : keywordPos;
+        }
+      }
+      return -1;
+    }
+  }
+}
+function lookAheadForOperator(data, pos) {
+  switch (data.charCodeAt(pos)) {
+    case 38 /* AMPERSAND */:
+    case 42 /* ASTERISK */:
+    case 94 /* CARET */:
+    case 33 /* EXCLAMATION */:
+    case 60 /* OPEN_ANGLE_BRACKET */:
+    case 37 /* PERCENT */:
+    case 124 /* PIPE */:
+    case 63 /* QUESTION */:
+    case 126 /* TILDE */:
+    case 43 /* PLUS */:
+    case 45 /* HYPHEN */:
+    case 58 /* COLON */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+    case 61 /* EQUAL */:
+      return pos + 1;
+    case 47 /* FORWARD_SLASH */:
+    case 123 /* OPEN_CURLY_BRACE */:
+    case 40 /* OPEN_PAREN */:
+      return pos;
+    case 46 /* PERIOD */:
+      return data.charCodeAt(pos + 1) === 46 /* PERIOD */ ? -1 : pos + 1;
+    default: {
+      for (const keyword of binaryKeywords) {
+        let nextPos = lookAheadFor(data, pos, keyword);
+        if (nextPos === -1)
+          continue;
+        const max = data.length - 1;
+        if (nextPos === max)
+          return -1;
+        let nextCode = data.charCodeAt(nextPos + 1);
+        if (isWhitespaceCode(nextCode)) {
+          nextPos = lookAheadWhile(isWhitespaceCode, data, nextPos + 2);
+          if (nextPos === max)
+            return -1;
+          nextCode = data.charCodeAt(nextPos);
+        } else if (isWordCode(nextCode)) {
+          return -1;
+        }
+        switch (nextCode) {
+          case 58 /* COLON */:
+          case 44 /* COMMA */:
+          case 61 /* EQUAL */:
+          case 47 /* FORWARD_SLASH */:
+          case 62 /* CLOSE_ANGLE_BRACKET */:
+          case 59 /* SEMICOLON */:
+            return -1;
+          default:
+            return nextPos;
         }
       }
+      return -1;
+    }
+  }
+}
+function canFollowDivision(code) {
+  return isWordCode(code) || 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 */;
+}
+function isWordCode(code) {
+  return code >= 65 /* UPPER_A */ && code <= 90 /* UPPER_Z */ || code >= 97 /* LOWER_A */ && code <= 122 /* LOWER_Z */ || code >= 48 /* NUMBER_0 */ && code <= 57 /* NUMBER_9 */ || code === 95 /* UNDERSCORE */;
+}
+function isIndentCode(code) {
+  return code === 9 /* TAB */ || code === 32 /* SPACE */;
+}
+function lookAheadWhile(match, data, pos) {
+  const max = data.length;
+  for (let i = pos; i < max; i++) {
+    if (!match(data.charCodeAt(i)))
+      return i;
+  }
+  return max - 1;
+}
+function lookBehindWhile(match, data, pos) {
+  let i = pos;
+  do {
+    if (!match(data.charCodeAt(i))) {
+      return i + 1;
+    }
+  } while (i--);
+  return 0;
+}
+function lookBehindFor(data, pos, str) {
+  let i = str.length;
+  const endPos = pos - i + 1;
+  if (endPos < 0)
+    return -1;
+  while (i--) {
+    if (data.charCodeAt(endPos + i) !== str.charCodeAt(i)) {
+      return -1;
     }
+  }
+  return endPos;
 }
-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 */;
+function lookAheadFor(data, pos, str) {
+  let i = str.length;
+  const endPos = pos + i;
+  if (endPos > data.length)
+    return -1;
+  while (i--) {
+    if (data.charCodeAt(pos + i) !== str.charCodeAt(i)) {
+      return -1;
+    }
+  }
+  return endPos - 1;
 }
 
 // src/states/HTML_COMMENT.ts
@@ -1174,7 +1833,11 @@ var HTML_COMMENT = {
   eol() {
   },
   eof(comment) {
-    this.emitError(comment, 16 /* MALFORMED_COMMENT */, "EOF reached while parsing comment");
+    this.emitError(
+      comment,
+      16 /* MALFORMED_COMMENT */,
+      "EOF reached while parsing comment"
+    );
   },
   return() {
   }
@@ -1348,11 +2011,10 @@ var INLINE_SCRIPT = {
     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.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseCurlyBrace;
     } else {
       const expr = this.enterState(states_exports.EXPRESSION);
+      expr.operators = true;
       expr.terminatedByEOL = true;
     }
   },
@@ -1387,7 +2049,11 @@ var JS_COMMENT_BLOCK = {
   eol() {
   },
   eof(comment) {
-    this.emitError(comment, 16 /* MALFORMED_COMMENT */, "EOF reached while parsing multi-line JavaScript comment");
+    this.emitError(
+      comment,
+      16 /* MALFORMED_COMMENT */,
+      "EOF reached while parsing multi-line JavaScript comment"
+    );
   },
   return() {
   }
@@ -1510,7 +2176,11 @@ var PLACEHOLDER = {
   },
   return(child) {
     if (child.start === child.end) {
-      this.emitError(child, 20 /* MALFORMED_PLACEHOLDER */, "Invalid placeholder, the expression cannot be missing");
+      this.emitError(
+        child,
+        20 /* MALFORMED_PLACEHOLDER */,
+        "Invalid placeholder, the expression cannot be missing"
+      );
     }
     this.pos++;
     this.exitState();
@@ -1550,7 +2220,7 @@ function checkForPlaceholder(parser, code) {
       parser.enterState(PLACEHOLDER).escape = escape;
       parser.pos += escape ? 2 : 3;
       parser.forward = 0;
-      parser.enterState(states_exports.EXPRESSION).terminator = 125 /* CLOSE_CURLY_BRACE */;
+      parser.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseCurlyBrace;
       return true;
     }
   }
@@ -1584,10 +2254,18 @@ var REGULAR_EXPRESSION = {
     }
   },
   eol(_, regExp) {
-    this.emitError(regExp, 9 /* INVALID_REGULAR_EXPRESSION */, "EOL reached while parsing regular expression");
+    this.emitError(
+      regExp,
+      9 /* INVALID_REGULAR_EXPRESSION */,
+      "EOL reached while parsing regular expression"
+    );
   },
   eof(regExp) {
-    this.emitError(regExp, 9 /* INVALID_REGULAR_EXPRESSION */, "EOF reached while parsing regular expression");
+    this.emitError(
+      regExp,
+      9 /* INVALID_REGULAR_EXPRESSION */,
+      "EOF reached while parsing regular expression"
+    );
   },
   return() {
   }
@@ -1621,7 +2299,11 @@ var STRING = {
   eol() {
   },
   eof(string) {
-    this.emitError(string, 10 /* INVALID_STRING */, "EOF reached while parsing string expression");
+    this.emitError(
+      string,
+      10 /* INVALID_STRING */,
+      "EOF reached while parsing string expression"
+    );
   },
   return() {
   }
@@ -1649,7 +2331,11 @@ var TAG_NAME = {
     switch (tagName.shorthandCode) {
       case 35 /* NUMBER_SIGN */:
         if (this.activeTag.hasShorthandId) {
-          return this.emitError(tagName, 12 /* INVALID_TAG_SHORTHAND */, "Multiple shorthand ID parts are not allowed on the same tag");
+          return this.emitError(
+            tagName,
+            12 /* INVALID_TAG_SHORTHAND */,
+            "Multiple shorthand ID parts are not allowed on the same tag"
+          );
         }
         this.activeTag.hasShorthandId = true;
         (_b = (_a = this.options).onTagShorthandId) == null ? void 0 : _b.call(_a, {
@@ -1680,12 +2366,26 @@ var TAG_NAME = {
           tag.type = tagType;
           if (tagType === 3 /* statement */) {
             if (!tag.concise) {
-              return this.emitError(tagName, 24 /* RESERVED_TAG_NAME */, `The "${this.read(tagName)}" tag is reserved and cannot be used as an HTML tag.`);
+              return this.emitError(
+                tagName,
+                24 /* 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, 25 /* ROOT_TAG_ONLY */, `"${this.read(tagName)}" can only be used at the root of the template.`);
+              return this.emitError(
+                tagName,
+                25 /* ROOT_TAG_ONLY */,
+                `"${this.read(
+                  tagName
+                )}" can only be used at the root of the template.`
+              );
             }
-            this.enterState(states_exports.EXPRESSION).terminatedByEOL = true;
+            const expr = this.enterState(states_exports.EXPRESSION);
+            expr.operators = true;
+            expr.terminatedByEOL = true;
           }
         }
         break;
@@ -1696,7 +2396,7 @@ var TAG_NAME = {
     if (code === 36 /* DOLLAR */ && this.lookAtCharCodeAhead(1) === 123 /* OPEN_CURLY_BRACE */) {
       this.pos += 2;
       this.forward = 0;
-      this.enterState(states_exports.EXPRESSION).terminator = 125 /* CLOSE_CURLY_BRACE */;
+      this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseCurlyBrace;
     } 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();
@@ -1718,7 +2418,11 @@ var TAG_NAME = {
     if (child.terminatedByEOL)
       return;
     if (child.start === child.end) {
-      this.emitError(child, 20 /* MALFORMED_PLACEHOLDER */, "Invalid placeholder, the expression cannot be missing");
+      this.emitError(
+        child,
+        20 /* MALFORMED_PLACEHOLDER */,
+        "Invalid placeholder, the expression cannot be missing"
+      );
     }
     const { quasis, expressions } = tagName;
     const start = child.start - 2;
@@ -1751,334 +2455,43 @@ var TEMPLATE_STRING = {
   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 */) {
+    switch (code) {
+      case 36 /* DOLLAR */:
+        if (this.lookAtCharCodeAhead(1) === 123 /* OPEN_CURLY_BRACE */) {
+          this.pos++;
+          this.enterState(states_exports.EXPRESSION).shouldTerminate = matchesCloseCurlyBrace;
+        }
+        break;
+      case 92 /* BACK_SLASH */:
         this.pos++;
-      } else if (code === 96 /* BACKTICK */) {
+        break;
+      case 96 /* BACKTICK */:
         this.pos++;
         this.exitState();
-      }
+        break;
     }
   },
   eof(templateString) {
-    this.emitError(templateString, 13 /* INVALID_TEMPLATE_STRING */, "EOF reached while parsing template string expression");
+    this.emitError(
+      templateString,
+      13 /* INVALID_TEMPLATE_STRING */,
+      "EOF reached while parsing template string expression"
+    );
   },
   eol() {
   },
   return(child) {
     if (child.start === child.end) {
-      this.emitError(child, 20 /* MALFORMED_PLACEHOLDER */, "Invalid placeholder, the expression cannot be missing");
+      this.emitError(
+        child,
+        20 /* MALFORMED_PLACEHOLDER */,
+        "Invalid placeholder, the expression cannot be missing"
+      );
     }
     this.pos++;
   }
 };
 
-// src/states/OPEN_TAG.ts
-var TAG_STAGE = /* @__PURE__ */ ((TAG_STAGE2) => {
-  TAG_STAGE2[TAG_STAGE2["UNKNOWN"] = 0] = "UNKNOWN";
-  TAG_STAGE2[TAG_STAGE2["VAR"] = 1] = "VAR";
-  TAG_STAGE2[TAG_STAGE2["ARGUMENT"] = 2] = "ARGUMENT";
-  TAG_STAGE2[TAG_STAGE2["PARAMS"] = 3] = "PARAMS";
-  TAG_STAGE2[TAG_STAGE2["ATTR_GROUP"] = 4] = "ATTR_GROUP";
-  return TAG_STAGE2;
-})(TAG_STAGE || {});
-var CONCISE_TAG_VAR_TERMINATORS = [
-  59 /* SEMICOLON */,
-  40 /* OPEN_PAREN */,
-  124 /* PIPE */,
-  61 /* EQUAL */,
-  44 /* COMMA */,
-  [58 /* COLON */, 61 /* EQUAL */]
-];
-var HTML_TAG_VAR_TERMINATORS = [
-  62 /* CLOSE_ANGLE_BRACKET */,
-  40 /* OPEN_PAREN */,
-  124 /* PIPE */,
-  61 /* EQUAL */,
-  44 /* COMMA */,
-  [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,
-      type: 0 /* html */,
-      parent,
-      start,
-      end: start,
-      stage: 0 /* UNKNOWN */,
-      parentTag: this.activeTag,
-      nestedIndent: void 0,
-      indent: this.indent,
-      hasShorthandId: false,
-      hasArgs: false,
-      hasAttrs: false,
-      selfClosed: false,
-      shorthandEnd: -1,
-      tagName: void 0,
-      concise: this.isConcise,
-      beginMixedMode: this.beginMixedMode || this.endingMixedModeAtEOL
-    };
-    this.beginMixedMode = false;
-    this.endingMixedModeAtEOL = false;
-    this.endText();
-    return tag;
-  },
-  exit(tag) {
-    var _a, _b;
-    const { selfClosed } = tag;
-    (_b = (_a = this.options).onOpenTagEnd) == null ? void 0 : _b.call(_a, {
-      start: this.pos - (this.isConcise ? 0 : selfClosed ? 2 : 1),
-      end: this.pos,
-      selfClosed
-    });
-    switch (selfClosed ? 2 /* void */ : tag.type) {
-      case 2 /* void */:
-      case 3 /* statement */: {
-        if (tag.beginMixedMode)
-          this.endingMixedModeAtEOL = true;
-        this.activeTag = tag.parentTag;
-        break;
-      }
-      case 1 /* text */:
-        if (this.isConcise) {
-          this.enterState(states_exports.CONCISE_HTML_CONTENT);
-        } else {
-          this.enterState(states_exports.PARSED_TEXT_CONTENT);
-        }
-        break;
-    }
-  },
-  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, 19 /* MALFORMED_OPEN_TAG */, 'EOF reached while within an attribute group (e.g. "[ ... ]").');
-        return;
-      }
-      this.exitState();
-    } else {
-      this.emitError(tag, 19 /* 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, 5 /* 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, 19 /* MALFORMED_OPEN_TAG */, '"-" not allowed as first character of attribute name');
-          return;
-        }
-        if (tag.stage === 4 /* ATTR_GROUP */) {
-          this.emitError(this.pos, 19 /* 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, 19 /* 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, 19 /* 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.selfClosed = true;
-      this.pos += 2;
-      this.exitState();
-      return;
-    }
-    if (code === 60 /* OPEN_ANGLE_BRACKET */) {
-      return this.emitError(this.pos, 2 /* INVALID_ATTRIBUTE_NAME */, 'Invalid attribute name. Attribute name cannot begin with the "<" character.');
-    }
-    if (code === 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;
-      }
-    }
-    if (isWhitespaceCode(code)) {
-    } else if (code === 44 /* COMMA */) {
-      this.pos++;
-      this.forward = 0;
-      this.consumeWhitespace();
-    } else if (code === 47 /* FORWARD_SLASH */ && !tag.hasAttrs) {
-      tag.stage = 1 /* VAR */;
-      this.pos++;
-      this.forward = 0;
-      if (isWhitespaceCode(this.lookAtCharCodeAhead(0))) {
-        return this.emitError(this.pos, 23 /* MISSING_TAG_VARIABLE */, "A slash was found that was not followed by a variable name or lhs expression");
-      }
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.terminatedByWhitespace = true;
-      expr.terminator = this.isConcise ? CONCISE_TAG_VAR_TERMINATORS : HTML_TAG_VAR_TERMINATORS;
-    } else if (code === 40 /* OPEN_PAREN */ && !tag.hasAttrs) {
-      if (tag.hasArgs) {
-        this.emitError(this.pos, 11 /* INVALID_TAG_ARGUMENT */, "A tag can only have one argument");
-        return;
-      }
-      tag.stage = 2 /* ARGUMENT */;
-      this.pos++;
-      this.forward = 0;
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.skipOperators = true;
-      expr.terminator = 41 /* CLOSE_PAREN */;
-    } else if (code === 124 /* PIPE */ && !tag.hasAttrs) {
-      tag.stage = 3 /* PARAMS */;
-      this.pos++;
-      this.forward = 0;
-      const expr = this.enterState(states_exports.EXPRESSION);
-      expr.skipOperators = true;
-      expr.terminator = 124 /* PIPE */;
-    } else {
-      this.forward = 0;
-      if (tag.tagName) {
-        this.enterState(states_exports.ATTRIBUTE);
-        tag.hasAttrs = true;
-      } else {
-        this.enterState(states_exports.TAG_NAME);
-      }
-    }
-  },
-  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, 23 /* MISSING_TAG_VARIABLE */, "A slash was found that was not followed by a variable name or lhs expression");
-            }
-            (_b = (_a = this.options).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.forward = 0;
-            } else {
-              tag.hasArgs = true;
-              (_d = (_c = this.options).onTagArgs) == null ? void 0 : _d.call(_c, {
-                start,
-                end,
-                value
-              });
-            }
-            break;
-          }
-          case 3 /* PARAMS */: {
-            const end = ++this.pos;
-            (_f = (_e = this.options).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);