1 files changed, 240 insertions, 25 deletions

diff --git a/src/parser/parse/read/expression.ts b/src/parser/parse/read/expression.ts
index 6ea0ebc56..bdd6c4b81 100644
--- a/src/parser/parse/read/expression.ts
+++ b/src/parser/parse/read/expression.ts
@@ -1,39 +1,254 @@
-import { parse_expression_at } from '../acorn.js';
+
+import type { BaseNode, Expression } from '../../interfaces';
 import { Parser } from '../index.js';
-import { whitespace } from '../../utils/patterns.js';
+import parseAstro from '../index.js';
 
-// @ts-ignore
-export default function read_expression(parser: Parser): string {
-  try {
-    const start = parser.index;
-    let index = parse_expression_at(parser.template, parser.index);
-    let num_parens = 0;
+interface ParseState {
+  source: string;
+  start: number;
+  index: number;
+  curlyCount: number;
+  bracketCount: number;
+  root: Expression;
+}
+
+function peek_char(state: ParseState) {
+  return state.source[state.index];
+}
+
+function peek_nonwhitespace(state: ParseState) {
+  let index = state.index;
+  do {
+    let char = state.source[index];
+    if(!/\s/.test(char)) {
+      return char;
+    }
+    index++;
+  } while(index < state.source.length);
+}
+
+function next_char(state: ParseState) {
+  return state.source[state.index++];
+}
+
+function in_bounds(state: ParseState) {
+  return state.index < state.source.length;
+}
+
+function consume_string(state: ParseState, stringChar: string) {
+  let inEscape;
+  do {
+    const char = next_char(state);
+
+    if(inEscape) {
+      inEscape = false;
+    } else if(char === '\\') {
+      inEscape = true;
+    } else if(char === stringChar) {
+      break;
+    }
+  } while(in_bounds(state));
+}
+
+function consume_multiline_comment(state: ParseState) {
+  do {
+    const char = next_char(state);
+
+    if(char === '*' && peek_char(state) === '/') {
+      break;
+    }
+  } while(in_bounds(state));
+}
 
-    for (let i = parser.index; i < start; i += 1) {
-      if (parser.template[i] === '(') num_parens += 1;
+function consume_line_comment(state: ParseState) {
+  do {
+    const char = next_char(state);
+    if(char === '\n') {
+      break;
     }
+  } while(in_bounds(state));
+}
+
+const voidElements = new Set(['area', 'base', 'br', 'col', 'command', 'embed', 
+  'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 
+  'track', 'wbr']);
 
-    while (num_parens > 0) {
-      const char = parser.template[index];
+function consume_tag(state: ParseState) {
+  const start = state.index - 1;
+  let tagName = '';
+  let inTag = false;
+  let inStart = true;
+  let selfClosed = false;
+  let inClose = false;
 
-      if (char === ')') {
-        num_parens -= 1;
-      } else if (!whitespace.test(char)) {
-        parser.error(
-          {
-            code: 'unexpected-token',
-            message: 'Expected )',
-          },
-          index
-        );
+  let bracketIndex = 1;
+  do {
+    const char = next_char(state);
+
+    switch(char) {
+      case '\'':
+      case '"': {
+        consume_string(state, char);
+        break;
+      }
+      case '<': {
+        inTag = false;
+        tagName = '';
+
+        if(peek_nonwhitespace(state) === '/') {
+          inClose = true;
+          bracketIndex--;
+        } else {
+          inStart = true;
+          bracketIndex++;
+        }
+        break;
       }
+      case '>': {
+        // An arrow function, probably
+        if(!inStart && !inClose) {
+          break;
+        }
+
+        bracketIndex--;
 
-      index += 1;
+        const addExpectedBrackets =
+          // Void elements don't need a closing
+          !voidElements.has(tagName.toLowerCase()) &&
+          // Self-closing don't need a closing
+          !selfClosed &&
+          // If we're in a start tag, we expect to find 2 more brackets
+          !inClose;
+
+        if(addExpectedBrackets) {
+          bracketIndex += 2;
+        }
+
+        inTag = false;
+        selfClosed = false;
+        inStart = false;
+        inClose = false;
+        break;
+      }
+      case ' ': {
+        inTag = true;
+        break;
+      }
+      case '/': {
+        if(inStart) {
+          selfClosed = true;
+        }
+        break;
+      }
+      default: {
+        if(!inTag) {
+          tagName += char;
+        }
+        break;
+      }
+    }
+
+    // Unclosed tags
+    if(state.curlyCount <= 0) {
+      break;
+    }
+
+    if(bracketIndex === 0) {
+      break;
     }
+  } while(in_bounds(state));
+
+  const source = state.source.substring(start, state.index);
 
-    parser.index = index;
 
-    return parser.template.substring(start, index);
+  const ast = parseAstro(source);
+  const fragment = ast.html;
+
+  return fragment;
+}
+
+function consume_expression(source: string, start: number): Expression {
+  const expr: Expression = {
+    type: 'Expression',
+    start,
+    end: Number.NaN,
+    codeStart: '',
+    codeEnd: '',
+    children: []
+  };
+
+  let codeEndStart: number = 0;
+  const state: ParseState = {
+    source, start, index: start,
+    curlyCount: 1,
+    bracketCount: 0,
+    root: expr
+  };
+
+  do {
+    const char = next_char(state);
+    
+    switch(char) {
+      case '{': {
+        state.curlyCount++;
+        break;
+      }
+      case '}': {
+        state.curlyCount--;
+        break;
+      }
+      case '<': {
+        expr.codeStart = source.substring(start, state.index - 1);
+        const tag = consume_tag(state);
+        expr.children.push(tag);
+        codeEndStart = state.index;
+        break;
+      }
+      case '\'':
+      case '"':
+      case '`': {
+        consume_string(state, char);
+        break;
+      }
+      case '/': {
+        switch(peek_char(state)) {
+          case '/': {
+            consume_line_comment(state);
+            break;
+          }
+          case '*': {
+            consume_multiline_comment(state);
+            break;
+          }
+        }
+      }
+    }
+  } while(in_bounds(state) && state.curlyCount > 0);
+
+  expr.end = state.index - 1;
+
+  if(codeEndStart) {
+    expr.codeEnd = source.substring(codeEndStart, expr.end);
+  } else {
+    expr.codeStart = source.substring(start, expr.end);
+  }
+
+  return expr;
+}
+
+export const parse_expression_at = (source: string, index: number): Expression => {
+  const expression = consume_expression(source, index);
+
+  return expression;
+};
+
+// @ts-ignore
+export default function read_expression(parser: Parser) {
+  try {
+    debugger;
+    const expression = parse_expression_at(parser.template, parser.index);
+    parser.index = expression.end;
+    return expression;
   } catch (err) {
     parser.acorn_error(err);
   }