@jqhtml/parser 2.2.222

package/dist/lexer.js

@@ -0,0 +1,1446 @@
+// JQHTML Lexer - Simple character scanner, no regex
+// Tracks positions for source map support
+import { JQHTMLParseError } from './errors.js';
+export var TokenType;
+(function (TokenType) {
+    // Literals
+    TokenType["TEXT"] = "TEXT";
+    // JQHTML tags
+    TokenType["EXPRESSION_START"] = "EXPRESSION_START";
+    TokenType["EXPRESSION_UNESCAPED"] = "EXPRESSION_UNESCAPED";
+    TokenType["CODE_START"] = "CODE_START";
+    TokenType["TAG_END"] = "TAG_END";
+    // Comments
+    TokenType["COMMENT"] = "COMMENT";
+    // Component definition
+    TokenType["DEFINE_START"] = "DEFINE_START";
+    TokenType["DEFINE_END"] = "DEFINE_END";
+    TokenType["COMPONENT_NAME"] = "COMPONENT_NAME";
+    // Slots (v2)
+    TokenType["SLOT_START"] = "SLOT_START";
+    TokenType["SLOT_END"] = "SLOT_END";
+    TokenType["SLOT_NAME"] = "SLOT_NAME";
+    // HTML tags
+    TokenType["TAG_OPEN"] = "TAG_OPEN";
+    TokenType["TAG_CLOSE"] = "TAG_CLOSE";
+    TokenType["TAG_NAME"] = "TAG_NAME";
+    TokenType["SELF_CLOSING"] = "SELF_CLOSING";
+    // Attributes
+    TokenType["ATTR_NAME"] = "ATTR_NAME";
+    TokenType["ATTR_VALUE"] = "ATTR_VALUE";
+    // Delimiters
+    TokenType["COLON"] = "COLON";
+    TokenType["SEMICOLON"] = "SEMICOLON";
+    TokenType["GT"] = "GT";
+    TokenType["LT"] = "LT";
+    TokenType["SLASH"] = "SLASH";
+    TokenType["EQUALS"] = "EQUALS";
+    TokenType["QUOTE"] = "QUOTE";
+    // Special
+    TokenType["EOF"] = "EOF";
+    TokenType["NEWLINE"] = "NEWLINE";
+    TokenType["WHITESPACE"] = "WHITESPACE";
+    // JavaScript code
+    TokenType["JAVASCRIPT"] = "JAVASCRIPT";
+})(TokenType || (TokenType = {}));
+export class Lexer {
+    input;
+    position = 0;
+    line = 1;
+    column = 1;
+    tokens = [];
+    // Track saved positions for accurate token creation
+    savedPosition = null;
+    constructor(input) {
+        // Preprocess: Normalize all line endings to \n (handles \r\n and \r)
+        // This ensures the lexer only needs to handle \n throughout
+        let processed = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        // Preprocess: Replace JQHTML comments (<%-- --%) with equivalent newlines to preserve line mapping
+        processed = this.preprocessComments(processed);
+        // Preprocess: Replace HTML comments (<!-- -->) outside Define tags with equivalent newlines
+        processed = this.preprocessHTMLComments(processed);
+        // Preprocess: Insert // for empty lines in code blocks to preserve line mapping
+        processed = this.preprocessCodeBlocks(processed);
+        this.input = processed;
+    }
+    /**
+     * Save current position for later token creation
+     */
+    savePosition() {
+        this.savedPosition = {
+            line: this.line,
+            column: this.column,
+            offset: this.position
+        };
+        return this.savedPosition;
+    }
+    /**
+     * Get saved position or current position
+     */
+    getSavedPosition() {
+        if (this.savedPosition) {
+            const pos = this.savedPosition;
+            this.savedPosition = null;
+            return pos;
+        }
+        return {
+            line: this.line,
+            column: this.column,
+            offset: this.position
+        };
+    }
+    /**
+     * Replace <%-- comment --%> with equivalent number of newlines
+     * This ensures line mapping stays accurate while removing comment content
+     */
+    preprocessComments(input) {
+        let result = input;
+        let searchPos = 0;
+        while (true) {
+            // Find next comment start
+            const startIdx = result.indexOf('<%--', searchPos);
+            if (startIdx === -1)
+                break;
+            // Find matching comment end
+            const endIdx = result.indexOf('--%>', startIdx + 4);
+            if (endIdx === -1) {
+                // Unclosed comment - leave it for parser to report error
+                break;
+            }
+            // Extract the comment including delimiters
+            const commentText = result.substring(startIdx, endIdx + 4);
+            // Count newlines in the comment
+            const newlineCount = (commentText.match(/\n/g) || []).length;
+            // Replace comment with spaces and same number of newlines
+            // We preserve the same total length to keep position tracking accurate
+            let replacement = '';
+            let charsNeeded = commentText.length;
+            // First, add the newlines at their original positions
+            let commentPos = 0;
+            for (let i = 0; i < commentText.length; i++) {
+                if (commentText[i] === '\n') {
+                    replacement += '\n';
+                }
+                else {
+                    replacement += ' ';
+                }
+            }
+            // Replace the comment with the spacing
+            result = result.substring(0, startIdx) + replacement + result.substring(endIdx + 4);
+            // Move search position past this replacement
+            searchPos = startIdx + replacement.length;
+        }
+        return result;
+    }
+    /**
+     * Replace HTML comments (<!-- -->) that appear OUTSIDE of <Define> tags
+     * This strips documentation comments before component definitions
+     * HTML comments INSIDE <Define> tags are preserved in the output
+     */
+    preprocessHTMLComments(input) {
+        let result = input;
+        let searchPos = 0;
+        let insideDefine = false;
+        while (searchPos < result.length) {
+            // Check if we're entering or leaving a Define tag
+            if (result.substring(searchPos, searchPos + 8) === '<Define:') {
+                insideDefine = true;
+                searchPos += 8;
+                continue;
+            }
+            if (result.substring(searchPos, searchPos + 9) === '</Define:') {
+                insideDefine = false;
+                searchPos += 9;
+                continue;
+            }
+            // Only strip HTML comments if we're outside Define tags
+            if (!insideDefine && result.substring(searchPos, searchPos + 4) === '<!--') {
+                const startIdx = searchPos;
+                // Find matching comment end
+                const endIdx = result.indexOf('-->', searchPos + 4);
+                if (endIdx === -1) {
+                    // Unclosed comment - leave it for lexer to report error
+                    break;
+                }
+                // Extract the comment including delimiters
+                const commentText = result.substring(startIdx, endIdx + 3);
+                // Replace comment with spaces and same number of newlines to preserve line mapping
+                let replacement = '';
+                for (let i = 0; i < commentText.length; i++) {
+                    if (commentText[i] === '\n') {
+                        replacement += '\n';
+                    }
+                    else {
+                        replacement += ' ';
+                    }
+                }
+                // Replace the comment with the spacing
+                result = result.substring(0, startIdx) + replacement + result.substring(endIdx + 3);
+                // Move search position past this replacement
+                searchPos = startIdx + replacement.length;
+            }
+            else {
+                searchPos++;
+            }
+        }
+        return result;
+    }
+    /**
+     * Preprocess code blocks and expressions
+     * - Insert comment markers for empty lines in code blocks
+     * - Collapse multi-line expressions to single line with trailing newlines
+     * This ensures 1:1 line mapping in generated code
+     */
+    preprocessCodeBlocks(input) {
+        let result = input;
+        let searchPos = 0;
+        while (true) {
+            // Find next <% sequence
+            let startIdx = result.indexOf('<%', searchPos);
+            if (startIdx === -1)
+                break;
+            // Check what type of block this is
+            const isExpression = result[startIdx + 2] === '=';
+            const isUnescapedExpression = result.substring(startIdx + 2, startIdx + 4) === '!=';
+            if (isExpression || isUnescapedExpression) {
+                // Handle expressions: collapse to single line
+                const exprStart = isUnescapedExpression ? startIdx + 4 : startIdx + 3;
+                // Find matching %> considering strings
+                const endIdx = this.findClosingTag(result, exprStart);
+                if (endIdx === -1) {
+                    // Unclosed expression - leave it for parser to report error
+                    searchPos = startIdx + 2;
+                    continue;
+                }
+                // Extract the expression content
+                const exprContent = result.substring(exprStart, endIdx);
+                // Count newlines in the expression
+                const newlineCount = (exprContent.match(/\n/g) || []).length;
+                if (newlineCount > 0) {
+                    // Strip line comments BEFORE collapsing to avoid breaking parser
+                    let processedExpr = exprContent;
+                    // Replace // comments with spaces (preserve length for sourcemaps)
+                    let cleaned = '';
+                    let inString = false;
+                    let stringDelim = '';
+                    let escaped = false;
+                    for (let i = 0; i < processedExpr.length; i++) {
+                        const ch = processedExpr[i];
+                        const next = processedExpr[i + 1] || '';
+                        // Handle escape sequences
+                        if (escaped) {
+                            cleaned += ch;
+                            escaped = false;
+                            continue;
+                        }
+                        if (ch === '\\' && inString) {
+                            cleaned += ch;
+                            escaped = true;
+                            continue;
+                        }
+                        // Track strings
+                        if (!inString && (ch === '"' || ch === "'" || ch === '`')) {
+                            inString = true;
+                            stringDelim = ch;
+                            cleaned += ch;
+                        }
+                        else if (inString && ch === stringDelim) {
+                            inString = false;
+                            cleaned += ch;
+                        }
+                        else if (!inString && ch === '/' && next === '/') {
+                            // Found line comment - replace with spaces until newline
+                            cleaned += ' ';
+                            i++; // skip second /
+                            cleaned += ' ';
+                            while (i + 1 < processedExpr.length && processedExpr[i + 1] !== '\n') {
+                                i++;
+                                cleaned += ' ';
+                            }
+                        }
+                        else {
+                            cleaned += ch;
+                        }
+                    }
+                    // Collapse multi-line expression to single line
+                    // Replace all newlines with spaces to preserve token separation
+                    const collapsedExpr = cleaned.replace(/\n/g, ' ');
+                    // Add trailing newlines after the expression
+                    const trailingNewlines = '\n'.repeat(newlineCount);
+                    // Reconstruct with collapsed expression and trailing newlines
+                    const prefix = result.substring(0, exprStart);
+                    const suffix = result.substring(endIdx);
+                    result = prefix + collapsedExpr + suffix.substring(0, 2) + trailingNewlines + suffix.substring(2);
+                }
+                searchPos = startIdx + 2;
+            }
+            else {
+                // Handle code blocks: insert /* empty line */ for empty lines
+                const endIdx = this.findClosingTag(result, startIdx + 2);
+                if (endIdx === -1) {
+                    // Unclosed code block - leave it for parser to report error
+                    break;
+                }
+                // Extract the code block content between <% and %>
+                const blockContent = result.substring(startIdx + 2, endIdx);
+                // Process the content line by line
+                const lines = blockContent.split('\n');
+                const processedLines = [];
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    const trimmed = line.trim();
+                    // Don't add placeholders on the last line if it's empty
+                    // (this would be right before the %>)
+                    if (trimmed === '' && i < lines.length - 1) {
+                        // Empty line - use /* */ instead of // to avoid breaking code
+                        // Extra trailing space helps with alignment
+                        processedLines.push(' /* empty line */ ');
+                    }
+                    else {
+                        // Line has code or is the last line - keep as is
+                        processedLines.push(line);
+                    }
+                }
+                // Reconstruct the code block
+                const processedContent = processedLines.join('\n');
+                result = result.substring(0, startIdx + 2) + processedContent + result.substring(endIdx);
+                // Move search position past this block
+                searchPos = startIdx + 2 + processedContent.length + 2; // +2 for %>
+            }
+        }
+        return result;
+    }
+    /**
+     * Find the closing %> tag, properly handling strings and comments
+     */
+    findClosingTag(input, startPos) {
+        let pos = startPos;
+        let inString = false;
+        let stringDelimiter = '';
+        let inComment = false;
+        let commentType = '';
+        while (pos < input.length - 1) {
+            const char = input[pos];
+            const nextChar = input[pos + 1];
+            // Handle string literals
+            if (!inComment) {
+                if (!inString && (char === '"' || char === "'" || char === '`')) {
+                    inString = true;
+                    stringDelimiter = char;
+                }
+                else if (inString && char === stringDelimiter) {
+                    // Check if it's escaped
+                    let escapeCount = 0;
+                    let checkPos = pos - 1;
+                    while (checkPos >= 0 && input[checkPos] === '\\') {
+                        escapeCount++;
+                        checkPos--;
+                    }
+                    if (escapeCount % 2 === 0) {
+                        inString = false;
+                        stringDelimiter = '';
+                    }
+                }
+            }
+            // Handle comments
+            if (!inString && !inComment) {
+                if (char === '/' && nextChar === '/') {
+                    inComment = true;
+                    commentType = 'line';
+                }
+                else if (char === '/' && nextChar === '*') {
+                    inComment = true;
+                    commentType = 'block';
+                }
+            }
+            else if (inComment) {
+                if (commentType === 'line' && char === '\n') {
+                    inComment = false;
+                    commentType = '';
+                }
+                else if (commentType === 'block' && char === '*' && nextChar === '/') {
+                    inComment = false;
+                    commentType = '';
+                    pos++; // Skip the /
+                }
+            }
+            // Check for closing tag only if not in string or comment
+            if (!inString && !inComment) {
+                if (char === '%' && nextChar === '>') {
+                    return pos;
+                }
+            }
+            pos++;
+        }
+        return -1; // Not found
+    }
+    tokenize() {
+        while (this.position < this.input.length) {
+            this.scan_next();
+        }
+        this.add_token(TokenType.EOF, '', this.position, this.position);
+        return this.tokens;
+    }
+    scan_next() {
+        const start = this.position;
+        const start_line = this.line;
+        const start_column = this.column;
+        // Check for JQHTML tags first
+        // Comments are now preprocessed out, so we don't need to check for them
+        // Check for invalid <%== syntax (common mistake)
+        if (this.match_sequence('<%==')) {
+            const error = new JQHTMLParseError('Invalid expression syntax: <%== is not valid JQHTML syntax', this.line, this.column - 4, // Point to the start of <%==
+            this.input);
+            error.suggestion = '\n\nValid expression syntax:\n' +
+                '  <%= expr %>   - Escaped output (safe, default)\n' +
+                '  <%!= expr %>  - Unescaped HTML output (raw)\n\n' +
+                'Did you mean:\n' +
+                '  <%= ... %>   for escaped output, or\n' +
+                '  <%!= ... %>  for unescaped/raw HTML output?';
+            throw error;
+        }
+        if (this.match_sequence('<%!=')) {
+            this.add_token(TokenType.EXPRESSION_UNESCAPED, '<%!=', start, this.position);
+            this.scan_expression();
+            return;
+        }
+        if (this.match_sequence('<%=')) {
+            this.add_token(TokenType.EXPRESSION_START, '<%=', start, this.position);
+            this.scan_expression();
+            return;
+        }
+        if (this.match_sequence('<%')) {
+            this.add_token(TokenType.CODE_START, '<%', start, this.position);
+            this.scan_code_block();
+            return;
+        }
+        if (this.match_sequence('%>')) {
+            this.add_token(TokenType.TAG_END, '%>', start, this.position);
+            return;
+        }
+        // Check for Define tags
+        if (this.match_sequence('<Define:')) {
+            this.add_token(TokenType.DEFINE_START, '<Define:', start, this.position);
+            this.scan_component_name();
+            return;
+        }
+        if (this.match_sequence('</Define:')) {
+            this.add_token(TokenType.DEFINE_END, '</Define:', start, this.position);
+            this.scan_component_name();
+            return;
+        }
+        // Check for slot tags (v2)
+        if (this.match_sequence('</Slot:')) {
+            this.add_token(TokenType.SLOT_END, '</Slot:', start, this.position);
+            this.scan_slot_name();
+            return;
+        }
+        if (this.match_sequence('<Slot:')) {
+            this.add_token(TokenType.SLOT_START, '<Slot:', start, this.position);
+            this.scan_slot_name();
+            return;
+        }
+        // Check for HTML comment first
+        if (this.current_char() === '<' && this.peek_ahead(1) === '!' &&
+            this.peek_ahead(2) === '-' && this.peek_ahead(3) === '-') {
+            this.scan_html_comment();
+            return;
+        }
+        // Check for HTML tags (including components)
+        if (this.current_char() === '<') {
+            // Peek ahead to see if this is an HTML tag
+            if (this.peek_ahead(1) === '/') {
+                // Closing tag
+                if (this.is_tag_name_char(this.peek_ahead(2))) {
+                    this.scan_closing_tag();
+                    return;
+                }
+            }
+            else if (this.is_tag_name_char(this.peek_ahead(1))) {
+                // Opening tag
+                this.scan_opening_tag();
+                return;
+            }
+        }
+        // Single character tokens
+        const char = this.current_char();
+        // Don't tokenize < and > separately when they're part of HTML
+        // They should be part of TEXT tokens
+        /*
+        if (char === '<') {
+          this.advance();
+          this.add_token(TokenType.LT, '<', start, this.position);
+          return;
+        }
+        
+        if (char === '>') {
+          this.advance();
+          this.add_token(TokenType.GT, '>', start, this.position);
+          return;
+        }
+        */
+        if (char === '\n') {
+            this.advance();
+            this.add_token(TokenType.NEWLINE, '\n', start, this.position);
+            return;
+        }
+        // Default: scan as text until next special character
+        this.scan_text();
+    }
+    scan_text() {
+        const start = this.position;
+        const start_line = this.line;
+        const start_column = this.column;
+        let text = '';
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            // Stop at any potential tag start
+            if (char === '<') {
+                // Check for HTML comment first - don't break, these should be in text
+                if (this.peek_ahead(1) === '!' &&
+                    this.peek_ahead(2) === '-' &&
+                    this.peek_ahead(3) === '-') {
+                    break; // HTML comment will be handled separately
+                }
+                // Peek ahead for special sequences
+                if (this.peek_ahead(1) === '%' ||
+                    this.peek_sequence_at(1, 'Slot:') || // Slot start
+                    this.peek_sequence_at(1, '/Slot:') || // Slot end
+                    this.peek_ahead(1) === 'D' && this.peek_sequence_at(1, 'Define:') ||
+                    this.peek_ahead(1) === '/' && this.peek_sequence_at(1, '/Define:')) {
+                    break;
+                }
+                // Also stop for HTML tags
+                if (this.peek_ahead(1) === '/' && this.is_tag_name_char(this.peek_ahead(2))) {
+                    break; // Closing tag
+                }
+                if (this.is_tag_name_char(this.peek_ahead(1))) {
+                    break; // Opening tag
+                }
+            }
+            if (char === '%' && this.peek_ahead(1) === '>') {
+                break;
+            }
+            text += char;
+            this.advance();
+        }
+        if (text.length > 0) {
+            this.add_token(TokenType.TEXT, text, start, this.position, start_line, start_column);
+        }
+    }
+    scan_code_block() {
+        // After <%, save the original position INCLUDING whitespace
+        const position_with_whitespace = this.position;
+        // Now skip whitespace to check for keywords
+        this.skip_whitespace();
+        const saved_position = this.position;
+        // It's regular JavaScript code - rewind to include whitespace
+        this.position = position_with_whitespace;
+        this.scan_javascript();
+    }
+    scan_comment() {
+        // Scan comment from <%-- to --%>
+        const start = this.position - 4; // Already consumed <%--
+        let comment = '';
+        while (this.position < this.input.length) {
+            if (this.match_sequence('--%>')) {
+                // Found end of comment
+                // Don't trim - we need to preserve whitespace for line mapping
+                this.add_token(TokenType.COMMENT, comment, start, this.position);
+                return;
+            }
+            const char = this.current_char();
+            comment += char;
+            this.advance();
+        }
+        // Error: unterminated comment
+        throw new JQHTMLParseError('Unterminated comment', this.line, this.column, this.input);
+    }
+    scan_html_comment() {
+        // Scan HTML comment from <!-- to -->
+        // Everything inside should be treated as raw text, no parsing
+        const start = this.position;
+        // Consume <!--
+        this.advance(); // <
+        this.advance(); // !
+        this.advance(); // -
+        this.advance(); // -
+        let comment = '<!--';
+        // Scan until we find -->
+        while (this.position < this.input.length) {
+            if (this.current_char() === '-' &&
+                this.peek_ahead(1) === '-' &&
+                this.peek_ahead(2) === '>') {
+                // Found end of HTML comment
+                comment += '-->';
+                this.advance(); // -
+                this.advance(); // -
+                this.advance(); // >
+                // Add the entire HTML comment as a TEXT token
+                // This ensures it gets passed through as-is to the output
+                this.add_token(TokenType.TEXT, comment, start, this.position);
+                return;
+            }
+            const char = this.current_char();
+            comment += char;
+            // Track line numbers for error reporting
+            if (char === '\n') {
+                this.line++;
+                this.column = 1;
+            }
+            else {
+                this.column++;
+            }
+            this.advance();
+        }
+        // Error: unterminated HTML comment
+        throw new JQHTMLParseError('Unterminated HTML comment', this.line, this.column, this.input);
+    }
+    scan_expression() {
+        // After <%=, scan JavaScript until %>
+        // Strip line comments from interpolation blocks to avoid breaking parser
+        this.scan_javascript(true);
+    }
+    scan_javascript(strip_line_comments = false) {
+        const start = this.position;
+        let code = '';
+        let in_string = false;
+        let string_delimiter = '';
+        let escape_next = false;
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            // Handle escape sequences in strings
+            if (escape_next) {
+                code += char;
+                this.advance();
+                escape_next = false;
+                continue;
+            }
+            // Handle backslash (escape character)
+            if (char === '\\' && in_string) {
+                escape_next = true;
+                code += char;
+                this.advance();
+                continue;
+            }
+            // Handle string delimiters
+            if ((char === '"' || char === "'" || char === '`') && !in_string) {
+                in_string = true;
+                string_delimiter = char;
+            }
+            else if (char === string_delimiter && in_string) {
+                in_string = false;
+                string_delimiter = '';
+            }
+            // Strip line comments in interpolation blocks (outside strings)
+            if (strip_line_comments && !in_string && char === '/' && this.peek_ahead(1) === '/') {
+                // Replace EVERY character from // up to (but not including) newline with = for debugging
+                // This maintains exact position alignment for sourcemaps
+                // Replace first /
+                code += ' ';
+                this.advance();
+                // Replace second /
+                code += ' ';
+                this.advance();
+                // Replace all comment text with spaces until we hit newline or %>
+                while (this.position < this.input.length) {
+                    const next = this.current_char();
+                    // Found newline - preserve it and stop
+                    if (next === '\n') {
+                        code += next;
+                        this.advance();
+                        break;
+                    }
+                    // Handle \r\n or \r
+                    if (next === '\r') {
+                        code += next;
+                        this.advance();
+                        // Check for \n following \r
+                        if (this.current_char() === '\n') {
+                            code += '\n';
+                            this.advance();
+                        }
+                        break;
+                    }
+                    // Found closing %> - stop (don't consume it)
+                    if (next === '%' && this.peek_ahead(1) === '>') {
+                        break;
+                    }
+                    // Replace this comment character with space
+                    code += ' ';
+                    this.advance();
+                }
+                continue;
+            }
+            // Only look for %> when not inside a string
+            if (!in_string && char === '%' && this.peek_ahead(1) === '>') {
+                break;
+            }
+            code += char;
+            this.advance();
+        }
+        // Don't trim when stripping comments - preserve whitespace for proper parsing
+        const finalCode = strip_line_comments ? code : code.trim();
+        if (finalCode.trim().length > 0) {
+            this.add_token(TokenType.JAVASCRIPT, finalCode, start, this.position);
+        }
+    }
+    scan_component_name() {
+        const start = this.position;
+        let name = '';
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            // Component names are alphanumeric with underscores
+            if ((char >= 'a' && char <= 'z') ||
+                (char >= 'A' && char <= 'Z') ||
+                (char >= '0' && char <= '9') ||
+                char === '_') {
+                name += char;
+                this.advance();
+            }
+            else {
+                break;
+            }
+        }
+        if (name.length > 0) {
+            this.add_token(TokenType.COMPONENT_NAME, name, start, this.position);
+        }
+        // Skip whitespace after component name
+        this.skip_whitespace();
+        // Also skip newlines after component name (for multiline Define tags)
+        while (this.current_char() === '\n' || this.current_char() === '\r') {
+            if (this.current_char() === '\n') {
+                this.add_token(TokenType.NEWLINE, '\n', this.position, this.position + 1);
+            }
+            this.advance();
+            this.skip_whitespace();
+        }
+        // If we see attributes, scan them
+        if (this.is_attribute_start_char(this.current_char())) {
+            this.scan_attributes();
+        }
+        else if (this.current_char() === '>') {
+            // Otherwise scan the closing >
+            const gt_start = this.position;
+            this.advance();
+            this.add_token(TokenType.GT, '>', gt_start, this.position);
+        }
+    }
+    scan_slot_name() {
+        const start = this.position;
+        let name = '';
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            // Slot names are alphanumeric with underscores, same as components
+            if ((char >= 'a' && char <= 'z') ||
+                (char >= 'A' && char <= 'Z') ||
+                (char >= '0' && char <= '9') ||
+                char === '_') {
+                name += char;
+                this.advance();
+            }
+            else {
+                break;
+            }
+        }
+        if (name.length > 0) {
+            this.add_token(TokenType.SLOT_NAME, name, start, this.position);
+        }
+        // Skip whitespace before attributes or closing
+        this.skip_whitespace();
+        // For self-closing slots, check for />
+        if (this.current_char() === '/' && this.peek_ahead(1) === '>') {
+            const slash_start = this.position;
+            this.advance(); // consume /
+            this.add_token(TokenType.SLASH, '/', slash_start, this.position);
+            const gt_start = this.position;
+            this.advance(); // consume >
+            this.add_token(TokenType.GT, '>', gt_start, this.position);
+        }
+        else if (this.current_char() === '>') {
+            // Regular closing >
+            const gt_start = this.position;
+            this.advance();
+            this.add_token(TokenType.GT, '>', gt_start, this.position);
+        }
+    }
+    match_sequence(sequence) {
+        if (this.position + sequence.length > this.input.length) {
+            return false;
+        }
+        for (let i = 0; i < sequence.length; i++) {
+            if (this.input[this.position + i] !== sequence[i]) {
+                return false;
+            }
+        }
+        // Consume the sequence
+        for (let i = 0; i < sequence.length; i++) {
+            this.advance();
+        }
+        return true;
+    }
+    match_keyword(keyword) {
+        const start = this.position;
+        // Match the keyword
+        for (let i = 0; i < keyword.length; i++) {
+            if (this.position + i >= this.input.length ||
+                this.input[this.position + i] !== keyword[i]) {
+                return false;
+            }
+        }
+        // Ensure it's not part of a larger word
+        const next_pos = this.position + keyword.length;
+        if (next_pos < this.input.length) {
+            const next_char = this.input[next_pos];
+            if ((next_char >= 'a' && next_char <= 'z') ||
+                (next_char >= 'A' && next_char <= 'Z') ||
+                (next_char >= '0' && next_char <= '9') ||
+                next_char === '_') {
+                return false;
+            }
+        }
+        // Consume the keyword
+        for (let i = 0; i < keyword.length; i++) {
+            this.advance();
+        }
+        return true;
+    }
+    peek_sequence(sequence) {
+        if (this.position + sequence.length > this.input.length) {
+            return false;
+        }
+        for (let i = 0; i < sequence.length; i++) {
+            if (this.input[this.position + i] !== sequence[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    peek_sequence_at(offset, sequence) {
+        const start = this.position + offset;
+        if (start + sequence.length > this.input.length) {
+            return false;
+        }
+        for (let i = 0; i < sequence.length; i++) {
+            if (this.input[start + i] !== sequence[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    skip_whitespace() {
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            if (char === ' ' || char === '\t' || char === '\r') {
+                this.advance();
+            }
+            else {
+                break;
+            }
+        }
+    }
+    current_char() {
+        return this.input[this.position] || '';
+    }
+    peek_ahead(offset) {
+        return this.input[this.position + offset] || '';
+    }
+    advance() {
+        if (this.current_char() === '\n') {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        this.position++;
+    }
+    add_token(type, value, start, end, line, column) {
+        // Calculate start position details
+        const startLine = line ?? this.line;
+        const startColumn = column ?? this.column;
+        // Calculate end position by scanning the value
+        let endLine = startLine;
+        let endColumn = startColumn;
+        let endOffset = end;
+        // Count lines and columns in the value to get accurate end position
+        for (let i = 0; i < value.length; i++) {
+            if (value[i] === '\n') {
+                endLine++;
+                endColumn = 1;
+            }
+            else {
+                endColumn++;
+            }
+        }
+        // For single character tokens, end column is start + 1
+        if (value.length === 1 && value !== '\n') {
+            endColumn = startColumn + 1;
+        }
+        this.tokens.push({
+            type,
+            value,
+            line: startLine, // Keep for backward compatibility
+            column: startColumn, // Keep for backward compatibility
+            start, // Keep for backward compatibility
+            end, // Keep for backward compatibility
+            loc: {
+                start: {
+                    line: startLine,
+                    column: startColumn,
+                    offset: start
+                },
+                end: {
+                    line: endLine,
+                    column: endColumn,
+                    offset: endOffset
+                }
+            }
+        });
+    }
+    is_tag_name_char(char) {
+        if (!char)
+            return false;
+        return (char >= 'a' && char <= 'z') ||
+            (char >= 'A' && char <= 'Z');
+    }
+    is_tag_name_continue_char(char) {
+        if (!char)
+            return false;
+        return this.is_tag_name_char(char) ||
+            (char >= '0' && char <= '9') ||
+            char === '-' || char === '_' || char === ':';
+    }
+    scan_opening_tag() {
+        const start = this.position;
+        this.advance(); // consume <
+        this.add_token(TokenType.TAG_OPEN, '<', start, this.position);
+        // Scan tag name
+        const name_start = this.position;
+        let name = '';
+        while (this.position < this.input.length &&
+            this.is_tag_name_continue_char(this.current_char())) {
+            name += this.current_char();
+            this.advance();
+        }
+        if (name.length > 0) {
+            this.add_token(TokenType.TAG_NAME, name, name_start, this.position);
+        }
+        // Scan attributes until > or />
+        this.scan_attributes();
+    }
+    scan_closing_tag() {
+        const start = this.position;
+        this.advance(); // consume <
+        this.advance(); // consume /
+        this.add_token(TokenType.TAG_CLOSE, '</', start, this.position);
+        // Scan tag name
+        const name_start = this.position;
+        let name = '';
+        while (this.position < this.input.length &&
+            this.is_tag_name_continue_char(this.current_char())) {
+            name += this.current_char();
+            this.advance();
+        }
+        if (name.length > 0) {
+            this.add_token(TokenType.TAG_NAME, name, name_start, this.position);
+        }
+        // Skip whitespace
+        this.skip_whitespace();
+        // Expect >
+        if (this.current_char() === '>') {
+            const gt_start = this.position;
+            this.advance();
+            this.add_token(TokenType.GT, '>', gt_start, this.position);
+        }
+    }
+    scan_attributes() {
+        while (this.position < this.input.length) {
+            this.skip_whitespace();
+            // Also skip newlines in attribute area
+            while (this.current_char() === '\n' || this.current_char() === '\r') {
+                if (this.current_char() === '\n') {
+                    this.add_token(TokenType.NEWLINE, '\n', this.position, this.position + 1);
+                }
+                this.advance();
+                this.skip_whitespace();
+            }
+            const char = this.current_char();
+            // Check for />
+            if (char === '/' && this.peek_ahead(1) === '>') {
+                const slash_start = this.position;
+                this.advance(); // consume /
+                this.advance(); // consume >
+                this.add_token(TokenType.SELF_CLOSING, '/>', slash_start, this.position);
+                return;
+            }
+            // Check for >
+            if (char === '>') {
+                const gt_start = this.position;
+                this.advance();
+                this.add_token(TokenType.GT, '>', gt_start, this.position);
+                return;
+            }
+            // Check for <% (conditional attribute start)
+            if (char === '<' && this.peek_ahead(1) === '%') {
+                const start = this.position;
+                this.advance(); // <
+                this.advance(); // %
+                this.add_token(TokenType.CODE_START, '<%', start, this.position);
+                this.scan_code_block();
+                // Consume the %> that scan_code_block left behind
+                if (this.current_char() === '%' && this.peek_ahead(1) === '>') {
+                    const tag_end_start = this.position;
+                    this.advance(); // %
+                    this.advance(); // >
+                    this.add_token(TokenType.TAG_END, '%>', tag_end_start, this.position);
+                }
+                // Continue scanning attributes - DO NOT return
+                continue;
+            }
+            // Must be an attribute
+            if (this.is_attribute_start_char(char)) {
+                this.scan_attribute();
+            }
+            else {
+                break;
+            }
+        }
+    }
+    is_attribute_start_char(char) {
+        if (!char)
+            return false;
+        return this.is_tag_name_char(char) || char === '$' || char === ':' || char === '@';
+    }
+    scan_attribute() {
+        const start = this.position;
+        let name = '';
+        // Scan attribute name
+        while (this.position < this.input.length) {
+            const char = this.current_char();
+            if (char === '=' || char === ' ' || char === '\t' ||
+                char === '\n' || char === '\r' || char === '>' ||
+                (char === '/' && this.peek_ahead(1) === '>') ||
+                (char === '<' && this.peek_ahead(1) === '%')) {
+                break;
+            }
+            name += char;
+            this.advance();
+        }
+        if (name.length > 0) {
+            this.add_token(TokenType.ATTR_NAME, name, start, this.position);
+        }
+        this.skip_whitespace();
+        // Check for = and value
+        if (this.current_char() === '=') {
+            const eq_start = this.position;
+            this.advance();
+            this.add_token(TokenType.EQUALS, '=', eq_start, this.position);
+            this.skip_whitespace();
+            // Scan attribute value
+            this.scan_attribute_value();
+        }
+    }
+    scan_attribute_value() {
+        const char = this.current_char();
+        // Check for common mistake: attr=<%= instead of attr="<%=
+        if (char === '<' && this.peek_ahead(1) === '%') {
+            const attr_context = this.get_current_attribute_context(); // Returns "attrname="
+            const is_dollar_attr = attr_context.startsWith('$');
+            const error = new JQHTMLParseError(`Attribute value cannot be assigned directly to <%= %> interpolation block.\n` +
+                `  Attribute: ${attr_context}<%`, this.line, this.column, this.input);
+            if (is_dollar_attr) {
+                error.suggestion = `\n\n$ attributes can use either:\n\n` +
+                    `1. Quoted interpolation (for string values):\n` +
+                    `   ✗ Wrong:   ${attr_context}<%= JSON.stringify(data) %>\n` +
+                    `   ✓ Correct: ${attr_context}"<%= JSON.stringify(data) %>"\n\n` +
+                    `2. Unquoted literal JavaScript (preferred):\n` +
+                    `   ✓ Correct: ${attr_context}JSON.stringify(data)\n` +
+                    `   ✓ Correct: ${attr_context}this.data.options\n` +
+                    `   ✓ Correct: ${attr_context}myVariable\n\n` +
+                    `The preferred approach is to use unquoted literal JavaScript\n` +
+                    `without <%= %> tags for $ attributes.`;
+            }
+            else {
+                error.suggestion = `\n\nRegular attributes must use quoted values:\n\n` +
+                    `   ✗ Wrong:   ${attr_context}<%= value %>\n` +
+                    `   ✓ Correct: ${attr_context}"<%= value %>"\n` +
+                    `   ✓ Correct: ${attr_context}"static text"\n\n` +
+                    `Always wrap attribute values in quotes.`;
+            }
+            throw error;
+        }
+        if (char === '"' || char === "'") {
+            // Check if this is an @ event attribute - they MUST be unquoted
+            const attr_context = this.get_current_attribute_context();
+            if (attr_context.startsWith('@')) {
+                const error = new JQHTMLParseError(`Event attributes (@) must have unquoted values to pass function references.\n` +
+                    `  Attribute: ${attr_context}=`, this.line, this.column, this.input);
+                error.suggestion = `\n\nEvent attributes must be unquoted:\n` +
+                    `  ✗ Wrong:   @click="handleClick"     (passes string, not function)\n` +
+                    `  ✓ Correct: @click=handleClick       (passes function reference)\n` +
+                    `  ✓ Correct: @click=this.handleClick  (passes method reference)\n\n` +
+                    `Quoted values only pass strings and cannot pass functions or callbacks.\n` +
+                    `In the component scope, 'this' refers to the component instance.`;
+                throw error;
+            }
+            // Quoted value - check for interpolation
+            const quote = char;
+            const quote_start = this.position;
+            this.advance(); // consume opening quote
+            // Check if value contains <%= or <%!=
+            if (this.value_contains_interpolation(quote)) {
+                // Rewind and scan with interpolation
+                this.position = quote_start;
+                this.advance(); // skip quote again
+                this.scan_interpolated_attribute_value(quote);
+            }
+            else {
+                // Simple value without interpolation
+                const value_start = this.position - 1; // Include opening quote
+                let value = quote; // Start with the quote
+                while (this.position < this.input.length && this.current_char() !== quote) {
+                    value += this.current_char();
+                    this.advance();
+                }
+                if (this.current_char() === quote) {
+                    value += quote; // Add closing quote
+                    this.advance(); // consume closing quote
+                }
+                if (value.length > 2 || value === '""' || value === "''") {
+                    this.add_token(TokenType.ATTR_VALUE, value, value_start, this.position);
+                }
+            }
+        }
+        else if (char === '(') {
+            // Parenthesized expression: $attr=(condition ? 'online' : 'offline')
+            const value_start = this.position;
+            let value = '';
+            let paren_depth = 0;
+            let in_string = false;
+            let string_delimiter = '';
+            let escape_next = false;
+            while (this.position < this.input.length) {
+                const ch = this.current_char();
+                // Handle escape sequences in strings
+                if (escape_next) {
+                    value += ch;
+                    this.advance();
+                    escape_next = false;
+                    continue;
+                }
+                // Handle backslash (escape character) inside strings
+                if (ch === '\\' && in_string) {
+                    escape_next = true;
+                    value += ch;
+                    this.advance();
+                    continue;
+                }
+                // Handle string delimiters
+                if ((ch === '"' || ch === "'" || ch === '`') && !in_string) {
+                    in_string = true;
+                    string_delimiter = ch;
+                }
+                else if (ch === string_delimiter && in_string) {
+                    in_string = false;
+                    string_delimiter = '';
+                }
+                // Count parentheses only outside strings
+                if (!in_string) {
+                    if (ch === '(') {
+                        paren_depth++;
+                    }
+                    else if (ch === ')') {
+                        paren_depth--;
+                        value += ch;
+                        this.advance();
+                        // Stop when we close the last parenthesis
+                        if (paren_depth === 0) {
+                            break;
+                        }
+                        continue;
+                    }
+                    // Stop at whitespace or tag end if not inside parentheses
+                    if (paren_depth === 0 && (ch === ' ' || ch === '\t' || ch === '\n' ||
+                        ch === '\r' || ch === '>' ||
+                        (ch === '/' && this.peek_ahead(1) === '>'))) {
+                        break;
+                    }
+                }
+                value += ch;
+                this.advance();
+            }
+            if (value.length > 0) {
+                this.add_token(TokenType.ATTR_VALUE, value, value_start, this.position);
+            }
+        }
+        else {
+            // Unquoted value - JavaScript identifier or member expression
+            // Valid chars: alphanumeric, underscore, period, dollar sign
+            // Can be prefixed with ! for negation
+            // Examples: myVar, this.method, obj.prop.subprop, $element, !this.canEdit
+            //
+            // RULES:
+            // - @ event attributes: MUST be unquoted (to pass functions)
+            // - $ attributes: Can be quoted (string) or unquoted (any JS value)
+            // - Regular attributes: MUST be quoted (strings only)
+            // Check attribute type
+            const attr_context = this.get_current_attribute_context();
+            const is_event_attr = attr_context.startsWith('@');
+            const is_dollar_attr = attr_context.startsWith('$');
+            // Regular attributes (not @ or $) must be quoted
+            if (!is_event_attr && !is_dollar_attr) {
+                const error = new JQHTMLParseError(`Regular HTML attributes must have quoted values.\n` +
+                    `  Attribute: ${attr_context}`, this.line, this.column, this.input);
+                error.suggestion = `\n\nRegular attributes must be quoted:\n` +
+                    `  ✗ Wrong:   ${attr_context}myValue\n` +
+                    `  ✓ Correct: ${attr_context}"myValue"\n` +
+                    `  ✓ Correct: ${attr_context}"prefix <%= this.data.value %> suffix"\n\n` +
+                    `Only @ event attributes (unquoted) and $ attributes (either) allow unquoted values:\n` +
+                    `  ✓ Correct: @click=this.handleClick  (passes function reference)\n` +
+                    `  ✓ Correct: $data=this.complexObject (passes object)\n` +
+                    `  ✓ Correct: $sid="my-id"              (passes string)`;
+                throw error;
+            }
+            const value_start = this.position;
+            let value = '';
+            let isFirstChar = true;
+            while (this.position < this.input.length) {
+                const ch = this.current_char();
+                // Allow ! only as the first character (negation operator)
+                if (isFirstChar && ch === '!') {
+                    value += ch;
+                    this.advance();
+                    isFirstChar = false;
+                    continue;
+                }
+                isFirstChar = false;
+                // Check if character is valid for JavaScript identifier/member expression/function call
+                const isValidChar = (ch >= 'a' && ch <= 'z') ||
+                    (ch >= 'A' && ch <= 'Z') ||
+                    (ch >= '0' && ch <= '9') ||
+                    ch === '_' ||
+                    ch === '.' ||
+                    ch === '$' ||
+                    ch === '(' || // Allow parentheses for function calls
+                    ch === ')' ||
+                    ch === ',' || // Allow commas in function arguments
+                    ch === '"' || // Allow quoted strings in function arguments
+                    ch === "'"; // Allow quoted strings in function arguments
+                if (!isValidChar) {
+                    // Stop at first non-valid character
+                    break;
+                }
+                value += ch;
+                this.advance();
+            }
+            if (value.length > 0) {
+                // Validate the pattern before accepting it
+                this.validate_unquoted_value(value, attr_context);
+                this.add_token(TokenType.ATTR_VALUE, value, value_start, this.position);
+            }
+        }
+    }
+    validate_unquoted_value(value, attr_context) {
+        // Allowed patterns:
+        // 1. Literals: true, false, null, undefined, 123, 45.67
+        // 2. Identifiers: myVar, $variable, _private
+        // 3. Property chains: obj.prop, MyClass.method, deep.nested.property
+        // 4. Function calls: func(), obj.method(), func(arg1, arg2)
+        // 5. Chains with calls: obj.method().property.another()
+        //
+        // NOT allowed:
+        // - Operators: +, -, *, /, %, =, ==, ===, &&, ||, etc.
+        // - Objects: {key: value}
+        // - Arrays: [1, 2, 3]
+        // - Ternary: condition ? a : b
+        // Check for disallowed operators
+        if (/[+\-*/%=<>!&|^~?:]/.test(value)) {
+            const error = new JQHTMLParseError(`Operators are not allowed in unquoted $ attribute values.\n` +
+                `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+            error.suggestion = `\n\nUnquoted $ attribute values must be simple references or function calls:\n\n` +
+                `✓ Allowed patterns:\n` +
+                `  - Literals:         $count=42  or  $active=true\n` +
+                `  - Variables:        $data=myVariable\n` +
+                `  - Property access:  $handler=Controller.method\n` +
+                `  - Function calls:   $value=getData()\n` +
+                `  - Complex chains:   $fetch=API.users.getAll()\n\n` +
+                `✗ Not allowed:\n` +
+                `  - Operators:        $value=a+b  (use quoted string or component logic)\n` +
+                `  - Ternary:          $class=active?'on':'off'  (use quoted string)\n` +
+                `  - Comparisons:      $show=count>5  (handle in component logic)\n\n` +
+                `If you need complex expressions, handle them in the component's on_load() or on_ready() method.`;
+            throw error;
+        }
+        // Check for object literals
+        if (value.trim().startsWith('{')) {
+            const error = new JQHTMLParseError(`Object literals are not allowed in unquoted $ attribute values.\n` +
+                `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+            error.suggestion = `\n\nUnquoted $ attribute values cannot contain object literals.\n\n` +
+                `If you need to pass an object, create it in the component:\n` +
+                `  ✗ Wrong:   $config={key:"value"}\n` +
+                `  ✓ Correct: In component: this.data.config = {key: "value"}\n` +
+                `            In template:  $config=this.data.config`;
+            throw error;
+        }
+        // Check for array literals
+        if (value.trim().startsWith('[')) {
+            const error = new JQHTMLParseError(`Array literals are not allowed in unquoted $ attribute values.\n` +
+                `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+            error.suggestion = `\n\nUnquoted $ attribute values cannot contain array literals.\n\n` +
+                `If you need to pass an array, create it in the component:\n` +
+                `  ✗ Wrong:   $items=[1,2,3]\n` +
+                `  ✓ Correct: In component: this.data.items = [1, 2, 3]\n` +
+                `            In template:  $items=this.data.items`;
+            throw error;
+        }
+        // Validate that parentheses are balanced
+        let parenDepth = 0;
+        let inString = false;
+        let stringChar = '';
+        for (let i = 0; i < value.length; i++) {
+            const ch = value[i];
+            // Track string boundaries
+            if ((ch === '"' || ch === "'") && !inString) {
+                inString = true;
+                stringChar = ch;
+            }
+            else if (ch === stringChar && inString) {
+                inString = false;
+                stringChar = '';
+            }
+            // Only count parentheses outside strings
+            if (!inString) {
+                if (ch === '(')
+                    parenDepth++;
+                if (ch === ')')
+                    parenDepth--;
+                if (parenDepth < 0) {
+                    const error = new JQHTMLParseError(`Unmatched closing parenthesis in unquoted $ attribute value.\n` +
+                        `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+                    error.suggestion = `\n\nCheck for mismatched parentheses in the attribute value.`;
+                    throw error;
+                }
+            }
+        }
+        if (parenDepth !== 0) {
+            const error = new JQHTMLParseError(`Unmatched opening parenthesis in unquoted $ attribute value.\n` +
+                `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+            error.suggestion = `\n\nCheck for mismatched parentheses in the attribute value.`;
+            throw error;
+        }
+        // Validate the overall pattern using regex
+        // Pattern: identifier(.identifier)*(( args? ))*
+        // This allows: var, obj.prop, func(), obj.method(arg1, arg2).chain().more
+        const pattern = /^!?[a-zA-Z_$][a-zA-Z0-9_$]*(\.[a-zA-Z_$][a-zA-Z0-9_$]*|\([^)]*\))*$|^(true|false|null|undefined|\d+(\.\d+)?)$/;
+        if (!pattern.test(value)) {
+            const error = new JQHTMLParseError(`Invalid syntax in unquoted $ attribute value.\n` +
+                `  Found: ${attr_context}${value}`, this.line, this.column, this.input);
+            error.suggestion = `\n\nUnquoted $ attribute values must follow these patterns:\n\n` +
+                `✓ Allowed:\n` +
+                `  - Number literals:  42, 3.14\n` +
+                `  - Boolean literals: true, false\n` +
+                `  - Null/undefined:   null, undefined\n` +
+                `  - Identifiers:      myVar, _private, $jQuery\n` +
+                `  - Property chains:  Controller.method, obj.deep.property\n` +
+                `  - Function calls:   getData(), API.fetch("url")\n` +
+                `  - Mixed chains:     obj.method().property.call()\n\n` +
+                `✗ Not allowed:\n` +
+                `  - Spaces in names\n` +
+                `  - Complex expressions with operators\n` +
+                `  - Object or array literals\n\n` +
+                `The value should be a simple reference to data, not complex logic.`;
+            throw error;
+        }
+    }
+    get_current_attribute_context() {
+        // Look back in tokens to find the current attribute name for error reporting
+        let i = this.tokens.length - 1;
+        while (i >= 0) {
+            const token = this.tokens[i];
+            if (token.type === TokenType.ATTR_NAME) {
+                // The @ or $ is already part of the attribute name
+                return token.value + '=';
+            }
+            // Stop if we hit a tag boundary
+            if (token.type === TokenType.TAG_OPEN || token.type === TokenType.TAG_CLOSE) {
+                break;
+            }
+            i--;
+        }
+        return '';
+    }
+    value_contains_interpolation(quote) {
+        // Look ahead to see if this quoted value contains <%= or <%!=
+        let pos = this.position;
+        while (pos < this.input.length && this.input[pos] !== quote) {
+            if (pos + 2 < this.input.length &&
+                this.input[pos] === '<' &&
+                this.input[pos + 1] === '%') {
+                return true;
+            }
+            pos++;
+        }
+        return false;
+    }
+    scan_interpolated_attribute_value(quote) {
+        let text_start = this.position;
+        let text = '';
+        while (this.position < this.input.length && this.current_char() !== quote) {
+            // Check for interpolation start
+            if (this.current_char() === '<' && this.peek_ahead(1) === '%') {
+                // Save any text before the interpolation
+                if (text.length > 0) {
+                    this.add_token(TokenType.ATTR_VALUE, text, text_start, this.position);
+                    text = '';
+                }
+                // Check what kind of expression
+                if (this.peek_ahead(2) === '!' && this.peek_ahead(3) === '=') {
+                    // <%!= expression %>
+                    this.advance(); // <
+                    this.advance(); // %
+                    this.advance(); // !
+                    this.advance(); // =
+                    this.add_token(TokenType.EXPRESSION_UNESCAPED, '<%!=', this.position - 4, this.position);
+                }
+                else if (this.peek_ahead(2) === '=') {
+                    // <%= expression %>
+                    this.advance(); // <
+                    this.advance(); // %
+                    this.advance(); // =
+                    this.add_token(TokenType.EXPRESSION_START, '<%=', this.position - 3, this.position);
+                }
+                else {
+                    // Just add as text
+                    text += this.current_char();
+                    this.advance();
+                    continue;
+                }
+                // Scan the JavaScript expression
+                this.scan_javascript();
+                // Consume %>
+                if (this.current_char() === '%' && this.peek_ahead(1) === '>') {
+                    const tag_end_start = this.position;
+                    this.advance(); // %
+                    this.advance(); // >
+                    this.add_token(TokenType.TAG_END, '%>', tag_end_start, this.position);
+                }
+                // Reset text tracking
+                text_start = this.position;
+            }
+            else {
+                text += this.current_char();
+                this.advance();
+            }
+        }
+        // Add any remaining text
+        if (text.length > 0) {
+            this.add_token(TokenType.ATTR_VALUE, text, text_start, this.position);
+        }
+        // Consume closing quote
+        if (this.current_char() === quote) {
+            this.advance();
+        }
+    }
+}
+//# sourceMappingURL=lexer.js.map