htmljs-parser 5.6.2 → 5.7.0

package/README.md

@@ -201,15 +201,18 @@ const parser = createParser({
         // TagType.void makes this a void element (cannot have children).
         return TagType.void;
       case "html-comment":
+      case "html-script":
+      case "html-style":
       case "script":
       case "style":
       case "textarea":
         // TagType.text makes the child content text only (with placeholders).
         return TagType.text;
-      case "class":
       case "export":
       case "import":
       case "static":
+      case "client":
+      case "server":
         // TagType.statement makes this a statement tag where the content following the tag name will be parsed as script code until we reach a new line, eg for `import x from "y"`).
         return TagType.statement;
     }

package/dist/index.js

@@ -793,15 +793,16 @@ var OPEN_TAG = {
     }
   }
 };
-function shouldTerminateConciseTagVar(code, data, pos) {
+function shouldTerminateConciseTagVar(code, data, pos, expression) {
   switch (code) {
     case 44 /* COMMA */:
     case 61 /* EQUAL */:
     case 124 /* PIPE */:
     case 40 /* OPEN_PAREN */:
     case 59 /* SEMICOLON */:
-    case 60 /* OPEN_ANGLE_BRACKET */:
       return true;
+    case 60 /* OPEN_ANGLE_BRACKET */:
+      return !expression.inType;
     case 45 /* HYPHEN */:
       return data.charCodeAt(pos + 1) === 45 /* HYPHEN */;
     case 58 /* COLON */:
@@ -810,15 +811,16 @@ function shouldTerminateConciseTagVar(code, data, pos) {
       return false;
   }
 }
-function shouldTerminateHtmlTagVar(code, data, pos) {
+function shouldTerminateHtmlTagVar(code, data, pos, expression) {
   switch (code) {
     case 124 /* PIPE */:
     case 44 /* COMMA */:
     case 61 /* EQUAL */:
     case 40 /* OPEN_PAREN */:
     case 62 /* CLOSE_ANGLE_BRACKET */:
-    case 60 /* OPEN_ANGLE_BRACKET */:
       return true;
+    case 60 /* OPEN_ANGLE_BRACKET */:
+      return !expression.inType;
     case 58 /* COLON */:
       return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
     case 47 /* FORWARD_SLASH */:
@@ -1618,20 +1620,26 @@ var DTD = {
 // src/states/EXPRESSION.ts
 var shouldTerminate = () => false;
 var unaryKeywords = [
+  "asserts",
   "async",
   "await",
-  "keyof",
   "class",
   "function",
+  "infer",
+  "is",
+  "keyof",
   "new",
+  "readonly",
   "typeof",
+  "unique",
   "void"
 ];
 var binaryKeywords = [
-  "instanceof",
-  "in",
   "as",
   "extends",
+  "instanceof",
+  // Note: instanceof must be checked before `in`
+  "in",
   "satisfies"
 ];
 var EXPRESSION = {
@@ -1646,6 +1654,9 @@ var EXPRESSION = {
       shouldTerminate,
       operators: false,
       wasComment: false,
+      inType: false,
+      forceType: false,
+      ternaryDepth: 0,
       terminatedByEOL: false,
       terminatedByWhitespace: false,
       consumeIndentedContent: false
@@ -1661,7 +1672,7 @@ var EXPRESSION = {
         }
         return;
       }
-      if (expression.shouldTerminate(code, this.data, this.pos)) {
+      if (expression.shouldTerminate(code, this.data, this.pos, expression)) {
         let wasExpression = false;
         if (expression.operators) {
           const prevNonWhitespacePos = lookBehindWhile(
@@ -1670,7 +1681,11 @@ var EXPRESSION = {
             this.pos - 1
           );
           if (prevNonWhitespacePos > expression.start) {
-            wasExpression = lookBehindForOperator(this.data, prevNonWhitespacePos) !== -1;
+            wasExpression = lookBehindForOperator(
+              expression,
+              this.data,
+              prevNonWhitespacePos
+            ) !== -1;
           }
         }
         if (!wasExpression) {
@@ -1689,6 +1704,38 @@ var EXPRESSION = {
       case 96 /* BACKTICK */:
         this.enterState(states_exports.TEMPLATE_STRING);
         break;
+      case 63 /* QUESTION */:
+        if (expression.operators && !expression.groupStack.length) {
+          expression.ternaryDepth++;
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
+      case 58 /* COLON */:
+        if (expression.operators && !expression.groupStack.length) {
+          if (expression.ternaryDepth) {
+            expression.ternaryDepth--;
+          } else {
+            expression.inType = true;
+          }
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
+      case 61 /* EQUAL */:
+        if (expression.operators && !expression.groupStack.length) {
+          if (this.lookAtCharCodeAhead(1) === 62 /* CLOSE_ANGLE_BRACKET */) {
+            this.pos++;
+          } else if (!expression.forceType) {
+            expression.inType = false;
+          }
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
       case 47 /* FORWARD_SLASH */:
         switch (this.lookAtCharCodeAhead(1)) {
           case 47 /* FORWARD_SLASH */:
@@ -1720,9 +1767,19 @@ var EXPRESSION = {
       case 123 /* OPEN_CURLY_BRACE */:
         expression.groupStack.push(125 /* CLOSE_CURLY_BRACE */);
         break;
+      case 60 /* OPEN_ANGLE_BRACKET */:
+        if (expression.inType) {
+          expression.groupStack.push(62 /* CLOSE_ANGLE_BRACKET */);
+        } else if (expression.operators && !expression.groupStack.length) {
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
       case 41 /* CLOSE_PAREN */:
       case 93 /* CLOSE_SQUARE_BRACKET */:
-      case 125 /* CLOSE_CURLY_BRACE */: {
+      case 125 /* CLOSE_CURLY_BRACE */:
+      case (expression.inType && 62 /* CLOSE_ANGLE_BRACKET */): {
         if (!expression.groupStack.length) {
           return this.emitError(
             expression,
@@ -1799,7 +1856,7 @@ function checkForOperators(parser, expression, eol) {
   if (!expression.operators)
     return false;
   const { pos, data } = parser;
-  if (lookBehindForOperator(data, pos) !== -1) {
+  if (lookBehindForOperator(expression, data, pos) !== -1) {
     parser.consumeWhitespace();
     parser.forward = 0;
     return true;
@@ -1814,9 +1871,10 @@ function checkForOperators(parser, expression, eol) {
     if (!expression.shouldTerminate(
       data.charCodeAt(nextNonSpace),
       data,
-      nextNonSpace
+      nextNonSpace,
+      expression
     )) {
-      const lookAheadPos = lookAheadForOperator(data, nextNonSpace);
+      const lookAheadPos = lookAheadForOperator(expression, data, nextNonSpace);
       if (lookAheadPos !== -1) {
         parser.pos = lookAheadPos;
         parser.forward = 0;
@@ -1826,7 +1884,7 @@ function checkForOperators(parser, expression, eol) {
   }
   return false;
 }
-function lookBehindForOperator(data, pos) {
+function lookBehindForOperator(expression, data, pos) {
   const curPos = pos - 1;
   const code = data.charCodeAt(curPos);
   switch (code) {
@@ -1837,12 +1895,13 @@ function lookBehindForOperator(data, pos) {
     case 61 /* EQUAL */:
     case 33 /* EXCLAMATION */:
     case 60 /* OPEN_ANGLE_BRACKET */:
-    case 62 /* CLOSE_ANGLE_BRACKET */:
     case 37 /* PERCENT */:
     case 124 /* PIPE */:
     case 63 /* QUESTION */:
     case 126 /* TILDE */:
       return curPos;
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+      return data.charCodeAt(curPos - 1) === 61 /* EQUAL */ ? curPos - 1 : expression.inType ? -1 : curPos;
     case 46 /* PERIOD */: {
       const nextPos = lookAheadWhile(isWhitespaceCode, data, pos);
       return isWordCode(data.charCodeAt(nextPos)) ? nextPos : -1;
@@ -1851,6 +1910,7 @@ function lookBehindForOperator(data, pos) {
     case 45 /* HYPHEN */: {
       if (data.charCodeAt(curPos - 1) === code) {
         return lookBehindForOperator(
+          expression,
           data,
           lookBehindWhile(isWhitespaceCode, data, curPos - 2)
         );
@@ -1861,15 +1921,14 @@ function lookBehindForOperator(data, pos) {
       for (const keyword of unaryKeywords) {
         const keywordPos = lookBehindFor(data, curPos, keyword);
         if (keywordPos !== -1) {
-          const prevCode = data.charCodeAt(keywordPos - 1);
-          return prevCode === 46 /* PERIOD */ || isWordCode(prevCode) ? -1 : keywordPos;
+          return isWordOrPeriodCode(data.charCodeAt(keywordPos - 1)) ? -1 : keywordPos;
         }
       }
       return -1;
     }
   }
 }
-function lookAheadForOperator(data, pos) {
+function lookAheadForOperator(expression, data, pos) {
   switch (data.charCodeAt(pos)) {
     case 38 /* AMPERSAND */:
     case 42 /* ASTERISK */:
@@ -1878,17 +1937,17 @@ function lookAheadForOperator(data, pos) {
     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 */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+    case 63 /* QUESTION */:
+    case 58 /* COLON */:
+    case 61 /* EQUAL */:
       return pos;
     case 46 /* PERIOD */: {
       const nextPos = lookAheadWhile(isWhitespaceCode, data, pos + 1);
@@ -1896,30 +1955,29 @@ function lookAheadForOperator(data, pos) {
     }
     default: {
       for (const keyword of binaryKeywords) {
-        let nextPos = lookAheadFor(data, pos, keyword);
-        if (nextPos === -1)
+        const keywordPos = lookAheadFor(data, pos, keyword);
+        if (keywordPos === -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 {
-          return -1;
-        }
-        switch (nextCode) {
+        if (!isWhitespaceCode(data.charCodeAt(keywordPos + 1)))
+          break;
+        const nextPos = lookAheadWhile(isWhitespaceCode, data, keywordPos + 2);
+        if (nextPos === data.length - 1)
+          break;
+        switch (data.charCodeAt(nextPos)) {
           case 58 /* COLON */:
           case 44 /* COMMA */:
           case 61 /* EQUAL */:
           case 47 /* FORWARD_SLASH */:
           case 62 /* CLOSE_ANGLE_BRACKET */:
           case 59 /* SEMICOLON */:
-            return -1;
+            break;
           default:
+            if (!expression.inType && (keyword === "as" || keyword === "satisfies")) {
+              expression.inType = true;
+              if (!(expression.ternaryDepth || expression.groupStack.length)) {
+                expression.forceType = true;
+              }
+            }
             return nextPos;
         }
       }
@@ -1945,6 +2003,9 @@ function canFollowDivision(code) {
       return false;
   }
 }
+function isWordOrPeriodCode(code) {
+  return code === 46 /* PERIOD */ || isWordCode(code);
+}
 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 == 36 /* DOLLAR */ || code === 95 /* UNDERSCORE */;
 }
@@ -2453,15 +2514,22 @@ var REGULAR_EXPRESSION = {
   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();
+    switch (code) {
+      case 92 /* BACK_SLASH */:
+        this.pos++;
+        break;
+      case 91 /* OPEN_SQUARE_BRACKET */:
+        regExp.isInCharSet = true;
+        break;
+      case 93 /* CLOSE_SQUARE_BRACKET */:
+        regExp.isInCharSet = false;
+        break;
+      case 47 /* FORWARD_SLASH */:
+        if (!regExp.isInCharSet) {
+          this.pos++;
+          this.exitState();
+        }
+        break;
     }
   },
   eol(_, regExp) {
@@ -2599,6 +2667,14 @@ var TAG_NAME = {
             expr.operators = true;
             expr.terminatedByEOL = true;
             expr.consumeIndentedContent = true;
+            const typeStatementMatch = this.lookAheadFor("declare ") || this.lookAheadFor("interface ") || this.lookAheadFor("type ");
+            if (typeStatementMatch) {
+              expr.inType = true;
+              expr.forceType = true;
+              this.pos += typeStatementMatch.length;
+              this.forward = 0;
+              this.consumeWhitespace();
+            }
           }
         }
         break;

package/dist/index.mjs

@@ -768,15 +768,16 @@ var OPEN_TAG = {
     }
   }
 };
-function shouldTerminateConciseTagVar(code, data, pos) {
+function shouldTerminateConciseTagVar(code, data, pos, expression) {
   switch (code) {
     case 44 /* COMMA */:
     case 61 /* EQUAL */:
     case 124 /* PIPE */:
     case 40 /* OPEN_PAREN */:
     case 59 /* SEMICOLON */:
-    case 60 /* OPEN_ANGLE_BRACKET */:
       return true;
+    case 60 /* OPEN_ANGLE_BRACKET */:
+      return !expression.inType;
     case 45 /* HYPHEN */:
       return data.charCodeAt(pos + 1) === 45 /* HYPHEN */;
     case 58 /* COLON */:
@@ -785,15 +786,16 @@ function shouldTerminateConciseTagVar(code, data, pos) {
       return false;
   }
 }
-function shouldTerminateHtmlTagVar(code, data, pos) {
+function shouldTerminateHtmlTagVar(code, data, pos, expression) {
   switch (code) {
     case 124 /* PIPE */:
     case 44 /* COMMA */:
     case 61 /* EQUAL */:
     case 40 /* OPEN_PAREN */:
     case 62 /* CLOSE_ANGLE_BRACKET */:
-    case 60 /* OPEN_ANGLE_BRACKET */:
       return true;
+    case 60 /* OPEN_ANGLE_BRACKET */:
+      return !expression.inType;
     case 58 /* COLON */:
       return data.charCodeAt(pos + 1) === 61 /* EQUAL */;
     case 47 /* FORWARD_SLASH */:
@@ -1593,20 +1595,26 @@ var DTD = {
 // src/states/EXPRESSION.ts
 var shouldTerminate = () => false;
 var unaryKeywords = [
+  "asserts",
   "async",
   "await",
-  "keyof",
   "class",
   "function",
+  "infer",
+  "is",
+  "keyof",
   "new",
+  "readonly",
   "typeof",
+  "unique",
   "void"
 ];
 var binaryKeywords = [
-  "instanceof",
-  "in",
   "as",
   "extends",
+  "instanceof",
+  // Note: instanceof must be checked before `in`
+  "in",
   "satisfies"
 ];
 var EXPRESSION = {
@@ -1621,6 +1629,9 @@ var EXPRESSION = {
       shouldTerminate,
       operators: false,
       wasComment: false,
+      inType: false,
+      forceType: false,
+      ternaryDepth: 0,
       terminatedByEOL: false,
       terminatedByWhitespace: false,
       consumeIndentedContent: false
@@ -1636,7 +1647,7 @@ var EXPRESSION = {
         }
         return;
       }
-      if (expression.shouldTerminate(code, this.data, this.pos)) {
+      if (expression.shouldTerminate(code, this.data, this.pos, expression)) {
         let wasExpression = false;
         if (expression.operators) {
           const prevNonWhitespacePos = lookBehindWhile(
@@ -1645,7 +1656,11 @@ var EXPRESSION = {
             this.pos - 1
           );
           if (prevNonWhitespacePos > expression.start) {
-            wasExpression = lookBehindForOperator(this.data, prevNonWhitespacePos) !== -1;
+            wasExpression = lookBehindForOperator(
+              expression,
+              this.data,
+              prevNonWhitespacePos
+            ) !== -1;
           }
         }
         if (!wasExpression) {
@@ -1664,6 +1679,38 @@ var EXPRESSION = {
       case 96 /* BACKTICK */:
         this.enterState(states_exports.TEMPLATE_STRING);
         break;
+      case 63 /* QUESTION */:
+        if (expression.operators && !expression.groupStack.length) {
+          expression.ternaryDepth++;
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
+      case 58 /* COLON */:
+        if (expression.operators && !expression.groupStack.length) {
+          if (expression.ternaryDepth) {
+            expression.ternaryDepth--;
+          } else {
+            expression.inType = true;
+          }
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
+      case 61 /* EQUAL */:
+        if (expression.operators && !expression.groupStack.length) {
+          if (this.lookAtCharCodeAhead(1) === 62 /* CLOSE_ANGLE_BRACKET */) {
+            this.pos++;
+          } else if (!expression.forceType) {
+            expression.inType = false;
+          }
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
       case 47 /* FORWARD_SLASH */:
         switch (this.lookAtCharCodeAhead(1)) {
           case 47 /* FORWARD_SLASH */:
@@ -1695,9 +1742,19 @@ var EXPRESSION = {
       case 123 /* OPEN_CURLY_BRACE */:
         expression.groupStack.push(125 /* CLOSE_CURLY_BRACE */);
         break;
+      case 60 /* OPEN_ANGLE_BRACKET */:
+        if (expression.inType) {
+          expression.groupStack.push(62 /* CLOSE_ANGLE_BRACKET */);
+        } else if (expression.operators && !expression.groupStack.length) {
+          this.pos++;
+          this.forward = 0;
+          this.consumeWhitespace();
+        }
+        break;
       case 41 /* CLOSE_PAREN */:
       case 93 /* CLOSE_SQUARE_BRACKET */:
-      case 125 /* CLOSE_CURLY_BRACE */: {
+      case 125 /* CLOSE_CURLY_BRACE */:
+      case (expression.inType && 62 /* CLOSE_ANGLE_BRACKET */): {
         if (!expression.groupStack.length) {
           return this.emitError(
             expression,
@@ -1774,7 +1831,7 @@ function checkForOperators(parser, expression, eol) {
   if (!expression.operators)
     return false;
   const { pos, data } = parser;
-  if (lookBehindForOperator(data, pos) !== -1) {
+  if (lookBehindForOperator(expression, data, pos) !== -1) {
     parser.consumeWhitespace();
     parser.forward = 0;
     return true;
@@ -1789,9 +1846,10 @@ function checkForOperators(parser, expression, eol) {
     if (!expression.shouldTerminate(
       data.charCodeAt(nextNonSpace),
       data,
-      nextNonSpace
+      nextNonSpace,
+      expression
     )) {
-      const lookAheadPos = lookAheadForOperator(data, nextNonSpace);
+      const lookAheadPos = lookAheadForOperator(expression, data, nextNonSpace);
       if (lookAheadPos !== -1) {
         parser.pos = lookAheadPos;
         parser.forward = 0;
@@ -1801,7 +1859,7 @@ function checkForOperators(parser, expression, eol) {
   }
   return false;
 }
-function lookBehindForOperator(data, pos) {
+function lookBehindForOperator(expression, data, pos) {
   const curPos = pos - 1;
   const code = data.charCodeAt(curPos);
   switch (code) {
@@ -1812,12 +1870,13 @@ function lookBehindForOperator(data, pos) {
     case 61 /* EQUAL */:
     case 33 /* EXCLAMATION */:
     case 60 /* OPEN_ANGLE_BRACKET */:
-    case 62 /* CLOSE_ANGLE_BRACKET */:
     case 37 /* PERCENT */:
     case 124 /* PIPE */:
     case 63 /* QUESTION */:
     case 126 /* TILDE */:
       return curPos;
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+      return data.charCodeAt(curPos - 1) === 61 /* EQUAL */ ? curPos - 1 : expression.inType ? -1 : curPos;
     case 46 /* PERIOD */: {
       const nextPos = lookAheadWhile(isWhitespaceCode, data, pos);
       return isWordCode(data.charCodeAt(nextPos)) ? nextPos : -1;
@@ -1826,6 +1885,7 @@ function lookBehindForOperator(data, pos) {
     case 45 /* HYPHEN */: {
       if (data.charCodeAt(curPos - 1) === code) {
         return lookBehindForOperator(
+          expression,
           data,
           lookBehindWhile(isWhitespaceCode, data, curPos - 2)
         );
@@ -1836,15 +1896,14 @@ function lookBehindForOperator(data, pos) {
       for (const keyword of unaryKeywords) {
         const keywordPos = lookBehindFor(data, curPos, keyword);
         if (keywordPos !== -1) {
-          const prevCode = data.charCodeAt(keywordPos - 1);
-          return prevCode === 46 /* PERIOD */ || isWordCode(prevCode) ? -1 : keywordPos;
+          return isWordOrPeriodCode(data.charCodeAt(keywordPos - 1)) ? -1 : keywordPos;
         }
       }
       return -1;
     }
   }
 }
-function lookAheadForOperator(data, pos) {
+function lookAheadForOperator(expression, data, pos) {
   switch (data.charCodeAt(pos)) {
     case 38 /* AMPERSAND */:
     case 42 /* ASTERISK */:
@@ -1853,17 +1912,17 @@ function lookAheadForOperator(data, pos) {
     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 */:
+    case 62 /* CLOSE_ANGLE_BRACKET */:
+    case 63 /* QUESTION */:
+    case 58 /* COLON */:
+    case 61 /* EQUAL */:
       return pos;
     case 46 /* PERIOD */: {
       const nextPos = lookAheadWhile(isWhitespaceCode, data, pos + 1);
@@ -1871,30 +1930,29 @@ function lookAheadForOperator(data, pos) {
     }
     default: {
       for (const keyword of binaryKeywords) {
-        let nextPos = lookAheadFor(data, pos, keyword);
-        if (nextPos === -1)
+        const keywordPos = lookAheadFor(data, pos, keyword);
+        if (keywordPos === -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 {
-          return -1;
-        }
-        switch (nextCode) {
+        if (!isWhitespaceCode(data.charCodeAt(keywordPos + 1)))
+          break;
+        const nextPos = lookAheadWhile(isWhitespaceCode, data, keywordPos + 2);
+        if (nextPos === data.length - 1)
+          break;
+        switch (data.charCodeAt(nextPos)) {
           case 58 /* COLON */:
           case 44 /* COMMA */:
           case 61 /* EQUAL */:
           case 47 /* FORWARD_SLASH */:
           case 62 /* CLOSE_ANGLE_BRACKET */:
           case 59 /* SEMICOLON */:
-            return -1;
+            break;
           default:
+            if (!expression.inType && (keyword === "as" || keyword === "satisfies")) {
+              expression.inType = true;
+              if (!(expression.ternaryDepth || expression.groupStack.length)) {
+                expression.forceType = true;
+              }
+            }
             return nextPos;
         }
       }
@@ -1920,6 +1978,9 @@ function canFollowDivision(code) {
       return false;
   }
 }
+function isWordOrPeriodCode(code) {
+  return code === 46 /* PERIOD */ || isWordCode(code);
+}
 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 == 36 /* DOLLAR */ || code === 95 /* UNDERSCORE */;
 }
@@ -2428,15 +2489,22 @@ var REGULAR_EXPRESSION = {
   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();
+    switch (code) {
+      case 92 /* BACK_SLASH */:
+        this.pos++;
+        break;
+      case 91 /* OPEN_SQUARE_BRACKET */:
+        regExp.isInCharSet = true;
+        break;
+      case 93 /* CLOSE_SQUARE_BRACKET */:
+        regExp.isInCharSet = false;
+        break;
+      case 47 /* FORWARD_SLASH */:
+        if (!regExp.isInCharSet) {
+          this.pos++;
+          this.exitState();
+        }
+        break;
     }
   },
   eol(_, regExp) {
@@ -2574,6 +2642,14 @@ var TAG_NAME = {
             expr.operators = true;
             expr.terminatedByEOL = true;
             expr.consumeIndentedContent = true;
+            const typeStatementMatch = this.lookAheadFor("declare ") || this.lookAheadFor("interface ") || this.lookAheadFor("type ");
+            if (typeStatementMatch) {
+              expr.inType = true;
+              expr.forceType = true;
+              this.pos += typeStatementMatch.length;
+              this.forward = 0;
+              this.consumeWhitespace();
+            }
           }
         }
         break;

package/dist/states/EXPRESSION.d.ts

@@ -3,9 +3,12 @@ export interface ExpressionMeta extends Meta {
     groupStack: number[];
     operators: boolean;
     wasComment: boolean;
+    inType: boolean;
+    forceType: boolean;
+    ternaryDepth: number;
     terminatedByEOL: boolean;
     terminatedByWhitespace: boolean;
     consumeIndentedContent: boolean;
-    shouldTerminate(code: number, data: string, pos: number): boolean;
+    shouldTerminate(code: number, data: string, pos: number, expression: ExpressionMeta): boolean;
 }
 export declare const EXPRESSION: StateDefinition<ExpressionMeta>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "htmljs-parser",
   "description": "An HTML parser recognizes content and string placeholders and allows JavaScript expressions as attribute values",
-  "version": "5.6.2",
+  "version": "5.7.0",
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.1",
@@ -63,18 +63,16 @@
     "bench": "tsx bench.mts",
     "build": "tsc -b && tsx build.mts",
     "change": "changeset add",
-    "ci:test": "nyc npm run mocha -- --forbid-only",
+    "ci:test": "nyc npm test -- --forbid-only",
     "format": "npm run lint:eslint -- --fix && npm run lint:prettier -- --write && (fixpack || true)",
     "lint": "tsc -b && npm run lint:eslint && npm run lint:prettier -- -l && fixpack",
     "lint:eslint": "eslint -f visualstudio .",
     "lint:prettier": "prettier \"./**/*{.ts,.js,.json,.md,.yml,rc}\"",
-    "mocha": "cross-env NODE_ENV=test mocha \"./src/**/__tests__/*.test.ts\"",
     "prepare": "husky",
     "release": "npm run build && changeset publish",
     "report": "open ./coverage/lcov-report/index.html",
-    "test": "npm run mocha -- --watch",
-    "test:inspect": "npm test -- --inspect",
-    "test:update": "npm run mocha -- --update",
+    "test": "cross-env NODE_ENV=test mocha \"./src/**/__tests__/*.test.ts\"",
+    "test:update": "npm test -- --update",
     "version": "changeset version && npm i --package-lock-only"
   },
   "types": "dist/index.d.ts"