tree-sitter-cfml 0.26.34

#include "tag.h"
#include "tree_sitter/parser.h"

#include <stdint.h>
#include <string.h>
#include <wctype.h>

enum TokenType {
    AUTOMATIC_SEMICOLON,
    TERNARY_QMARK,
    ELVIS_OPERATOR,
    LOGICAL_OR,
    CF_START_TAG_NAME,
    CF_END_TAG_NAME,
    ERRONEOUS_CF_END_TAG_NAME,
    CF_SELF_CLOSING_TAG_DELIMITER,
    CF_SELF_CLOSING_VOID_TAG_DELIMITER,
    IMPLICIT_CF_END_TAG,
    RAW_TEXT,
    CFML_COMMENT,
    CLOSE_TAG_DELIM,
    CLOSE_CF_TAG_DELIM,
    HTML_TEXT,
    CF_VOID_START_TAG_NAME,
    CF_SET_START_TAG_NAME,
    CF_IF_START_TAG_NAME,
    CF_IF_END_TAG_NAME,
    CF_ELSEIF_TAG_NAME,
    CF_ELSE_TAG_NAME,
    CF_RETURN_START_TAG_NAME,
    CF_OUTPUT_START_TAG_NAME,

    // Rules below this point are not included by the cfquery dialect
    SCRIPT_START_TAG_NAME,
    STYLE_START_TAG_NAME,
    START_TAG_NAME,
    END_TAG_NAME,
    ERRONEOUS_END_TAG_NAME,
    SELF_CLOSING_TAG_DELIMITER,
    IMPLICIT_END_TAG,

    START_HASH_EXPRESSION,
    SINGLE_HASH,
    HASH_EMPTY,

    CF_XML_START_TAG_NAME,
    CF_XML_END_TAG_NAME,
    CF_XML_CONTENT,

    CF_QUERY_START_TAG_NAME,
    CF_QUERY_END_TAG_NAME,
    CF_QUERY_CONTENT,

    CF_SCRIPT_START_TAG_NAME,
    CF_SCRIPT_END_TAG_NAME,
    CF_SCRIPT_CONTENT,

    CF_SAVECONTENT_START_TAG_NAME,
    CF_SAVECONTENT_END_TAG_NAME,
    CF_SAVECONTENT_BODY_CFML,
    CF_SAVECONTENT_BODY_HTML,
    CF_SAVECONTENT_BODY_SCRIPT,
    CF_SAVECONTENT_BODY_CSS,
    CF_SAVECONTENT_BODY_XML,
    CF_SAVECONTENT_BODY_SQL,
    CF_SAVECONTENT_BODY_RAW,
    CF_SAVECONTENT_CONTENT,

    CF_FUNCTION_START_TAG_NAME,
    CF_FUNCTION_END_TAG_NAME,

    CF_COMPONENT_START_TAG_NAME,
    CF_COMPONENT_END_TAG_NAME,

    CF_COMPONENT_CONTENT,
    SCANNER_SYMBOL_COUNT
};

typedef struct {
    Array(Tag) tags;
    Array(Tag) cf_tags;
    uint16_t cfoutput_depth;
    uint16_t cfcomponent_depth;
    uint16_t cffunction_depth;
} Scanner;

typedef enum {
    REJECT,     // Semicolon is illegal, ie a syntax error occurred
    NO_NEWLINE, // Unclear if semicolon will be legal, continue
    ACCEPT,     // Semicolon is legal, assuming a comment was encountered
} WhitespaceResult;

#define MAX(a, b) ((a) > (b) ? (a) : (b))

#define MAX_CF_END_DELIMITER_SIZE 256

#define VS(vs, sym, count) ((unsigned)(sym) < (count) && (vs)[(sym)])

static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); }

static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); }

// `iswspace` and friends are out-of-line, locale-aware library calls, and this
// scanner asks them about every character it reads. CFML source is ASCII in the
// parts that matter, so answer for ASCII inline and keep the library call for
// the non-ASCII tail, where its answer is the one that counts. In the "C"
// locale a parser embedded in an editor or a Node addon runs under, the two
// agree for ASCII by definition; a locale that classified an ASCII character
// differently would change these answers, but no locale in practice does.
static inline bool cf_isspace(int32_t c) {
    return c == ' ' || c == '\n' || c == '\t' || c == '\r' || c == '\v' || c == '\f' ||
           (c > 127 && iswspace((wint_t)c));
}

static inline bool cf_isalpha(int32_t c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
           (c > 127 && iswalpha((wint_t)c));
}

// `iswdigit` and `iswxdigit` answer only for the ASCII digits in every locale,
// so these need no fallback at all.
static inline bool cf_isdigit(int32_t c) { return c >= '0' && c <= '9'; }

static inline bool cf_isxdigit(int32_t c) {
    return cf_isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
}

static inline bool cf_isalnum(int32_t c) {
    return cf_isdigit(c) || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
           (c > 127 && iswalnum((wint_t)c));
}

static inline int32_t cf_toupper(int32_t c) {
    if (c >= 'a' && c <= 'z') return c - ('a' - 'A');
    if (c > 127) return (int32_t)towupper((wint_t)c);
    return c;
}

static inline int32_t cf_tolower(int32_t c) {
    if (c >= 'A' && c <= 'Z') return c + ('a' - 'A');
    if (c > 127) return (int32_t)towlower((wint_t)c);
    return c;
}

static inline bool tag_has_name(TagType type, bool is_cfquery_context) {
    return type == CUSTOM || type == CFML || type == CF_VOID || type == CF_SET ||
           type == CF_XML || type == CF_SCRIPT || type == CF_SAVECONTENT ||
           type == CF_QUERY || type == CF_OUTPUT || type == CF_FUNCTION || type == CF_RETURN ||
           type == CF_IF || type == CF_ELSEIF || type == CF_ELSE;
}

static inline bool valid_start_tag_name(const bool *vs, unsigned count) {
    return VS(vs, START_TAG_NAME, count) || VS(vs, SCRIPT_START_TAG_NAME, count) ||
           VS(vs, CF_START_TAG_NAME, count) ||
           VS(vs, CF_SET_START_TAG_NAME, count) || VS(vs, CF_VOID_START_TAG_NAME, count) ||
           VS(vs, CF_RETURN_START_TAG_NAME, count) || VS(vs, CF_XML_START_TAG_NAME, count) ||
           VS(vs, CF_QUERY_START_TAG_NAME, count) || VS(vs, CF_SCRIPT_START_TAG_NAME, count) ||
           VS(vs, CF_SAVECONTENT_START_TAG_NAME, count) || VS(vs, CF_OUTPUT_START_TAG_NAME, count) ||
           VS(vs, CF_FUNCTION_START_TAG_NAME, count) ||
           VS(vs, CF_COMPONENT_START_TAG_NAME, count) ||
           VS(vs, CF_IF_START_TAG_NAME, count) || VS(vs, CF_ELSEIF_TAG_NAME, count) ||
           VS(vs, CF_ELSE_TAG_NAME, count);
}

static inline bool valid_end_tag_name(const bool *vs, unsigned count) {
    return VS(vs, END_TAG_NAME, count) || VS(vs, CF_END_TAG_NAME, count) ||
           VS(vs, CF_XML_END_TAG_NAME, count) || VS(vs, CF_QUERY_END_TAG_NAME, count) ||
           VS(vs, CF_SCRIPT_END_TAG_NAME, count) || VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) ||
           VS(vs, CF_FUNCTION_END_TAG_NAME, count) ||
           VS(vs, CF_IF_END_TAG_NAME, count);
}

static inline bool valid_cf_start_tag_name(const bool *vs, unsigned count) {
    return VS(vs, CF_START_TAG_NAME, count) || VS(vs, CF_SET_START_TAG_NAME, count) ||
           VS(vs, CF_VOID_START_TAG_NAME, count) || VS(vs, CF_RETURN_START_TAG_NAME, count) ||
           VS(vs, CF_XML_START_TAG_NAME, count) || VS(vs, CF_QUERY_START_TAG_NAME, count) ||
           VS(vs, CF_SCRIPT_START_TAG_NAME, count) || VS(vs, CF_SAVECONTENT_START_TAG_NAME, count) ||
           VS(vs, CF_OUTPUT_START_TAG_NAME, count) || VS(vs, CF_FUNCTION_START_TAG_NAME, count) ||
           VS(vs, CF_COMPONENT_START_TAG_NAME, count) ||
           VS(vs, CF_IF_START_TAG_NAME, count) || VS(vs, CF_ELSEIF_TAG_NAME, count) ||
           VS(vs, CF_ELSE_TAG_NAME, count);
}

static inline bool valid_cf_end_tag_name(const bool *vs, unsigned count) {
    return VS(vs, CF_END_TAG_NAME, count) || VS(vs, CF_XML_END_TAG_NAME, count) ||
           VS(vs, CF_QUERY_END_TAG_NAME, count) || VS(vs, CF_SCRIPT_END_TAG_NAME, count) ||
           VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) || VS(vs, CF_FUNCTION_END_TAG_NAME, count) ||
           VS(vs, CF_IF_END_TAG_NAME, count);
}

static inline bool no_content_symbols(const bool *vs, unsigned count) {
    return !VS(vs, RAW_TEXT, count) && !VS(vs, CF_XML_CONTENT, count) &&
           !VS(vs, CF_QUERY_CONTENT, count) && !VS(vs, CF_SCRIPT_CONTENT, count);
}

static inline bool implicit_cf_end_tag_valid(const bool *vs, unsigned count) {
    return VS(vs, IMPLICIT_CF_END_TAG, count) && !VS(vs, CF_XML_END_TAG_NAME, count) &&
           !VS(vs, CF_QUERY_END_TAG_NAME, count) && !VS(vs, CF_SCRIPT_END_TAG_NAME, count) &&
           !VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) && !VS(vs, CF_FUNCTION_END_TAG_NAME, count) &&
           !VS(vs, CF_IF_END_TAG_NAME, count) &&
           !VS(vs, CF_ELSEIF_TAG_NAME, count) && !VS(vs, CF_ELSE_TAG_NAME, count);
}

// Each serialized tag array is a 4-byte header — `_serialized`, then `_count` —
// followed by `_serialized` entries. The two differ when the buffer runs out:
// deserialize restores that many real tags and pads to `_count` with empty ones.
//
// `reserve` is how many bytes must still be free *after* this array, so that
// whatever serialize writes next always fits. Getting this wrong is what caused
// #57: the second array found no room for its own header, skipped writing it,
// and left a stream whose shape no longer matched what deserialize expected —
// which then read past the end of the buffer. The header is written
// unconditionally now, and only the entries are ever dropped.
#define TAGS_HEADER_SIZE (2 * sizeof(uint16_t))

// How many bytes SERIALIZE_TAGS below will spend on one tag. Kept beside it so
// the two cannot drift: if the serialized shape of a tag changes, this changes.
static unsigned tag_serialized_size(const Tag *tag, bool is_cfquery_context) {
    if (!tag_has_name(tag->type, is_cfquery_context)) return 1;
    unsigned len = tag->tag_name.size;
    if (len > UINT8_MAX) len = UINT8_MAX;
    return 2 + len + sizeof(tag->html_depth);
}

#define SERIALIZE_TAGS(tags_field, buffer, size, reserve, is_cfquery_context) do { \
    uint16_t _count = (tags_field).size > UINT16_MAX ? UINT16_MAX : (tags_field).size; \
    uint16_t _serialized = 0; \
    unsigned _count_offset = (size); \
    unsigned _limit = TREE_SITTER_SERIALIZATION_BUFFER_SIZE - (reserve); \
    /* Unreachable with the reserves serialize() passes: the first array is */ \
    /* capped so the second's header always fits. Kept so a future caller */ \
    /* that reserves too little truncates rather than corrupting the stream. */ \
    if ((size) + TAGS_HEADER_SIZE > _limit) break; \
    (size) += TAGS_HEADER_SIZE; \
    for (; _serialized < _count; _serialized++) { \
        Tag _tag = (tags_field).contents[_serialized]; \
        if (tag_has_name(_tag.type, is_cfquery_context)) { \
            unsigned _len = _tag.tag_name.size; \
            if (_len > UINT8_MAX) _len = UINT8_MAX; \
            if ((size) + 2 + _len + sizeof(_tag.html_depth) > _limit) break; \
            (buffer)[(size)++] = (char)_tag.type; \
            (buffer)[(size)++] = (char)_len; \
            memcpy(&(buffer)[(size)], _tag.tag_name.contents, _len); \
            (size) += _len; \
            memcpy(&(buffer)[(size)], &_tag.html_depth, sizeof(_tag.html_depth)); \
            (size) += sizeof(_tag.html_depth); \
        } else { \
            if ((size) + 1 > _limit) break; \
            (buffer)[(size)++] = (char)_tag.type; \
        } \
    } \
    memcpy(&(buffer)[_count_offset], &_serialized, sizeof(_serialized)); \
    memcpy(&(buffer)[_count_offset + sizeof(_serialized)], &_count, sizeof(_count)); \
} while(0)

// Would pushing `incoming` take the two tag stacks past what `serialize` can
// write? tree-sitter caps that buffer at TREE_SITTER_SERIALIZATION_BUFFER_SIZE,
// and SERIALIZE_TAGS truncates when it runs out — deserialize then pads the
// remainder with nameless END_ sentinels, so the stack comes back *different*
// from the one that was saved and every later end-tag decision is made against
// tags that have lost their names.
//
// That is #55. A run of unpaired `<cf_foo>` tags nests, one level per tag, and
// past ~1KB of stack the whole document collapsed to a single ERROR at 1:1 —
// including the perfectly good `<cfscript>` block after the run. It is a BYTE
// budget rather than a tag count, which is what the bug report's "~71" missed:
// the limit moves with the tag NAME LENGTH, measured at 124 tags for `cf_a`
// down to 41 for `cf_runtest1234567890`.
//
// The cost is O(depth) per start tag rather than a maintained counter,
// deliberately: tags are popped from several places and a counter that drifts
// would reintroduce exactly the silent mismatch this exists to prevent. Real
// nesting depth is a handful of tags, so the loop is not measurable.
#define TAG_STACK_HEADROOM 256

static bool tag_stack_would_overflow(const Scanner *scanner, const Tag *incoming,
                                     bool is_cfquery_context) {
    const unsigned depths = sizeof(scanner->cfoutput_depth) +
                            sizeof(scanner->cfcomponent_depth) +
                            sizeof(scanner->cffunction_depth);
    // Headroom, and it is the whole point rather than a safety margin. The tag
    // that overflowed in the bug report was NOT one of the custom tags: 72
    // `<cf_runtest>` tags fit, and the `<cfscript>` after them became the 73rd
    // and was the one truncated. So a run of non-nesting tags must stop short of
    // the budget by enough for the tags that legitimately DO nest — a
    // `<cfscript>`, `<cfoutput>`, `<cfquery>` — to still fit after it. 256 bytes
    // is roughly 18 further named tags, well past any real nesting depth.
    const unsigned budget =
        TREE_SITTER_SERIALIZATION_BUFFER_SIZE -
        (2 * TAGS_HEADER_SIZE + depths) - TAG_STACK_HEADROOM;
    unsigned used = 0;
    for (unsigned i = 0; i < scanner->tags.size; i++) {
        used += tag_serialized_size(&scanner->tags.contents[i], is_cfquery_context);
    }
    for (unsigned i = 0; i < scanner->cf_tags.size; i++) {
        used += tag_serialized_size(&scanner->cf_tags.contents[i], is_cfquery_context);
    }
    return used + tag_serialized_size(incoming, is_cfquery_context) > budget;
}

static unsigned serialize(Scanner *scanner, char *buffer, bool is_cfquery_context) {
    unsigned size = 0;
    const unsigned depths = sizeof(scanner->cfoutput_depth) +
                            sizeof(scanner->cfcomponent_depth) +
                            sizeof(scanner->cffunction_depth);
    // `tags` must leave room for cf_tags' header and the three depth fields;
    // `cf_tags` only for the depths. That keeps every section present even when
    // the tag stacks are deep enough to fill the buffer on their own.
    SERIALIZE_TAGS(scanner->tags, buffer, size, TAGS_HEADER_SIZE + depths, is_cfquery_context);
    SERIALIZE_TAGS(scanner->cf_tags, buffer, size, depths, is_cfquery_context);
    if (size + depths <= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) {
        memcpy(&buffer[size], &scanner->cfoutput_depth, sizeof(scanner->cfoutput_depth));
        size += sizeof(scanner->cfoutput_depth);
        memcpy(&buffer[size], &scanner->cfcomponent_depth, sizeof(scanner->cfcomponent_depth));
        size += sizeof(scanner->cfcomponent_depth);
        memcpy(&buffer[size], &scanner->cffunction_depth, sizeof(scanner->cffunction_depth));
        size += sizeof(scanner->cffunction_depth);
    }
    return size;
}

// Deserialize runs once per external-token lex — 85,213 times over 300 corpus
// templates — which made rebuilding the tag stack from scratch the scanner's
// most expensive operation: a free and a malloc for every tag on it, on every
// call. The stack barely changes between calls, so the slots already in the
// array are reused in place and keep the name buffers they hold; only a change
// in depth touches the allocator now. Reuse is safe because every Tag owns its
// name buffer regardless of type (see `tag_free`), so overwriting a slot never
// strands one.
//
// Every read is bounded by `length` (#57). The counts and lengths driving this
// loop are read out of the buffer, so trusting them is trusting the input: an
// over-long `_serialized` used to walk straight off the end of the heap block
// and segfault the process. When a read would not fit, `_stop` latches and the
// remaining slots are emptied — the same state a serialize-side truncation
// leaves, so a short or foreign buffer costs scanner state, not memory safety.
#define DESERIALIZE_TAGS(tags_field, buffer, size, length, is_cfquery_context) do { \
    uint16_t _serialized = 0, _count = 0; \
    if ((size) + TAGS_HEADER_SIZE <= (length)) { \
        memcpy(&_serialized, &(buffer)[(size)], sizeof(_serialized)); (size) += sizeof(_serialized); \
        memcpy(&_count, &(buffer)[(size)], sizeof(_count)); (size) += sizeof(_count); \
    } \
    for (unsigned _i = _count; _i < (tags_field).size; _i++) tag_free(&(tags_field).contents[_i]); \
    if ((tags_field).size > _count) (tags_field).size = _count; \
    array_reserve(&(tags_field), _count); \
    while ((tags_field).size < _count) array_push(&(tags_field), tag_new()); \
    bool _stop = false; \
    for (unsigned _i = 0; _i < _count; _i++) { \
        Tag *_tag = &(tags_field).contents[_i]; \
        bool _filled = false; \
        if (!_stop && _i < _serialized && (size) + 1 <= (length)) { \
            TagType _type = (TagType)(unsigned char)(buffer)[(size)]; \
            if (!tag_has_name(_type, is_cfquery_context)) { \
                (size) += 1; \
                _tag->type = _type; \
                _tag->tag_name.size = 0; \
                _tag->html_depth = 0; \
                _filled = true; \
            } else if ((size) + 2 <= (length)) { \
                uint16_t _len = (uint8_t)(buffer)[(size) + 1]; \
                if ((size) + 2 + _len + sizeof(_tag->html_depth) <= (length)) { \
                    (size) += 2; \
                    _tag->type = _type; \
                    array_reserve(&_tag->tag_name, _len); \
                    /* memcpy(NULL, …, 0) is undefined; a zero-length name */ \
                    /* can leave `contents` NULL. */ \
                    if (_len) memcpy(_tag->tag_name.contents, &(buffer)[(size)], _len); \
                    _tag->tag_name.size = _len; \
                    (size) += _len; \
                    memcpy(&_tag->html_depth, &(buffer)[(size)], sizeof(_tag->html_depth)); \
                    (size) += sizeof(_tag->html_depth); \
                    _filled = true; \
                } \
            } \
        } \
        if (!_filled) { \
            _stop = true; \
            _tag->type = END_; \
            _tag->tag_name.size = 0; \
            _tag->html_depth = 0; \
        } \
    } \
} while(0)

static void deserialize(Scanner *scanner, const char *buffer, unsigned length, bool is_cfquery_context) {
    scanner->cfoutput_depth = 0;
    scanner->cfcomponent_depth = 0;
    scanner->cffunction_depth = 0;
    if (length > 0) {
        unsigned size = 0;
        DESERIALIZE_TAGS(scanner->tags, buffer, size, length, is_cfquery_context);
        DESERIALIZE_TAGS(scanner->cf_tags, buffer, size, length, is_cfquery_context);
        if (size + sizeof(scanner->cfoutput_depth) <= length) {
            memcpy(&scanner->cfoutput_depth, &buffer[size], sizeof(scanner->cfoutput_depth));
            size += sizeof(scanner->cfoutput_depth);
        }
        if (size + sizeof(scanner->cfcomponent_depth) <= length) {
            memcpy(&scanner->cfcomponent_depth, &buffer[size], sizeof(scanner->cfcomponent_depth));
            size += sizeof(scanner->cfcomponent_depth);
        }
        if (size + sizeof(scanner->cffunction_depth) <= length) {
            memcpy(&scanner->cffunction_depth, &buffer[size], sizeof(scanner->cffunction_depth));
            size += sizeof(scanner->cffunction_depth);
        }
    } else {
        for (unsigned i = 0; i < scanner->tags.size; i++) tag_free(&scanner->tags.contents[i]);
        array_clear(&scanner->tags);
        for (unsigned i = 0; i < scanner->cf_tags.size; i++) tag_free(&scanner->cf_tags.contents[i]);
        array_clear(&scanner->cf_tags);
    }
}

typedef struct {
    String tag_name;
    bool is_cf_tag;
} TagNameResult;

static TagNameResult scan_tag_name(TSLexer *lexer, bool is_cfquery_context) {
    TagNameResult result;
    String tag_name = array_new();
    bool is_cf_tag = false;

    // One allocation instead of the four `array_push` would make growing from
    // empty to a typical tag name a byte at a time. Longer names still grow.
    array_reserve(&tag_name, TAG_NAME_FIELD);

    // ColdFusion tags might start with 'C', ie. <cfcomponent or <cfcontinue
    if ( lexer->lookahead == 'c' || lexer->lookahead == 'C' ) {
        array_push(&tag_name, cf_toupper(lexer->lookahead));
        advance(lexer);
        if (lexer->lookahead == 'f' || lexer->lookahead == 'F') {
            is_cf_tag = true;
            array_delete(&tag_name);
            advance(lexer);
        }
    }

    while (( cf_isalnum(lexer->lookahead) || lexer->lookahead == '-' || lexer->lookahead == '_' || lexer->lookahead == ':' )) {
        array_push(&tag_name, cf_toupper(lexer->lookahead));
        advance(lexer);
    }

    result.tag_name = tag_name;
    result.is_cf_tag = is_cf_tag;

    return result;
}

static bool scan_comment(TSLexer *lexer, bool is_cfquery_context) {
    if (lexer->lookahead != '-') {
        return false;
    }
    advance(lexer);
    if (lexer->lookahead != '-') {
        return false;
    }

    advance(lexer);

    // IE conditional comments: <!--[if ...]>...<![endif]--> or <!--<![endif]-->
    // These don't nest — just scan until -->
    if (lexer->lookahead == '[' || lexer->lookahead == '<') {
        unsigned close_dashes = 0;
        while (lexer->lookahead) {
            if (lexer->lookahead == '-') {
                close_dashes++;
            } else if (lexer->lookahead == '>' && close_dashes >= 2) {
                lexer->result_symbol = CFML_COMMENT;
                advance(lexer);
                lexer->mark_end(lexer);
                return true;
            } else {
                close_dashes = 0;
            }
            advance(lexer);
        }
        return false;
    }

    unsigned dashes = 0;
    unsigned direction = -1;
    unsigned nesting = 1;

    while (lexer->lookahead) {
        switch (lexer->lookahead) {
            case '-':
                ++dashes;
                if ( direction == 1 && dashes >= 2 ) {
                    ++nesting;
                    direction = -1;
                    dashes = 0;
                }
                break;
            case '>':
                if (dashes >= 2) {
                    --nesting;
                    lexer->result_symbol = CFML_COMMENT;
                    advance(lexer);
                    lexer->mark_end(lexer);
                    if ( nesting == 0 ) {
                        return true;
                    }
                    dashes = 0;
                    direction = -1;
                    continue;
                }
                direction = -1;
                dashes = 0;
                break;
            case '<':
                direction = 0;
                dashes = 0;
                break;
            case '!':
                if ( direction == 0 ) {
                    direction = 1;
                    break;
                }
                direction = -1;
                dashes = 0;
                break;
            default:
                direction = -1;
                dashes = 0;
                break;
        }
        advance(lexer);
    }
    return false;
}

static WhitespaceResult scan_whitespace_and_comments(TSLexer *lexer, bool *scanned_comment, bool consume, bool is_cfquery_context) {
    bool saw_block_newline = false;
    for (;;) {
        while (cf_isspace(lexer->lookahead)) {
            skip(lexer);
        }

        if (lexer->lookahead == '/') {
            skip(lexer);

            if (lexer->lookahead == '/') {
                skip(lexer);
                while (lexer->lookahead != 0 && lexer->lookahead != '\n' && lexer->lookahead != 0x2028 && lexer->lookahead != 0x2029) {
                    skip(lexer);
                }
                *scanned_comment = true;
            } else if (lexer->lookahead == '*') {
                skip(lexer);
                while (lexer->lookahead != 0) {
                    if (lexer->lookahead == '*') {
                        skip(lexer);
                        if (lexer->lookahead == '/') {
                            skip(lexer);
                            *scanned_comment = true;

                            if (lexer->lookahead != '/' && !consume) {
                                return saw_block_newline ? ACCEPT : NO_NEWLINE;
                            }

                            break;
                        }
                    } else if (lexer->lookahead == '\n' || lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
                        saw_block_newline = true;
                        skip(lexer);
                    } else {
                        skip(lexer);
                    }
                }
            } else {
                return REJECT;
            }
        } else {
            return ACCEPT;
        }
    }
}


// Consume the body of a CFML comment, the lexer sitting just past the opening
// `<!---`. CFML comments nest, so track depth. Stops at EOF on an unterminated
// comment rather than spinning.
static void skip_cfml_comment_body(TSLexer *lexer) {
    unsigned depth = 1;
    while (lexer->lookahead) {
        if (lexer->lookahead == '<') {
            advance(lexer);
            if (lexer->lookahead != '!') continue;
            advance(lexer);
            unsigned dashes = 0;
            while (lexer->lookahead == '-') {
                dashes++;
                advance(lexer);
            }
            if (dashes >= 3) depth++;
            continue;
        }
        if (lexer->lookahead == '-') {
            unsigned dashes = 0;
            while (lexer->lookahead == '-') {
                dashes++;
                advance(lexer);
            }
            if (dashes >= 3 && lexer->lookahead == '>') {
                advance(lexer);
                if (--depth == 0) return;
            }
            continue;
        }
        advance(lexer);
    }
}

static bool scan_html_text(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context,
                           const bool *valid_symbols, unsigned count) {
    // Check if we're inside a script/style tag
    bool in_script_style = false;
    if (scanner->tags.size > 0) {
        TagType type = array_back(&scanner->tags)->type;
        if (type == SCRIPT || type == STYLE) {
            in_script_style = true;
        }
    }

    // saw_text will be true if we see any non-whitespace content, or any whitespace content that is not a newline and
    // does not immediately follow a newline.
    bool saw_text = false;
    // at_newline will be true if we are currently at a newline, or if we are at whitespace that is not a newline but
    // immediately follows a newline.
    bool at_newline = false;

    bool saw_any = false;

    if (in_script_style) {
        // Inside script/style: consume until #, <cf, </cf, or </script|</style
        lexer->mark_end(lexer);
        while (lexer->lookahead != 0 && lexer->lookahead != '#') {
            if (lexer->lookahead == '<') {
                // Peek for <cf or </cf or </script|</style
                advance(lexer);
                if (cf_toupper(lexer->lookahead) == 'C') {
                    advance(lexer);
                    if (cf_toupper(lexer->lookahead) == 'F') {
                        break;
                    }
                    lexer->mark_end(lexer);
                    saw_text = true;
                    saw_any = true;
                    continue;
                } else if (lexer->lookahead == '/') {
                    advance(lexer);
                    if (cf_toupper(lexer->lookahead) == 'C') {
                        advance(lexer);
                        if (cf_toupper(lexer->lookahead) == 'F') {
                            break;
                        }
                        lexer->mark_end(lexer);
                        saw_text = true;
                        saw_any = true;
                        continue;
                    } else if (cf_toupper(lexer->lookahead) == 'S') {
                        // Potential </script or </style - stop
                        break;
                    }
                    lexer->mark_end(lexer);
                    saw_text = true;
                    saw_any = true;
                    continue;
                } else if (lexer->lookahead == '!') {
                    // See scan_raw_text: `#` inside a CFML comment is never
                    // interpolated, so the comment is consumed whole.
                    advance(lexer);
                    if (lexer->lookahead == '-') {
                        advance(lexer);
                        if (lexer->lookahead == '-') {
                            advance(lexer);
                            if (lexer->lookahead == '-') {
                                skip_cfml_comment_body(lexer);
                            }
                        }
                    }
                    lexer->mark_end(lexer);
                    saw_text = true;
                    saw_any = true;
                    continue;
                }
                lexer->mark_end(lexer);
                saw_text = true;
                saw_any = true;
                continue;
            }
            saw_text = true;
            saw_any = true;
            advance(lexer);
            lexer->mark_end(lexer);
        }
        lexer->result_symbol = HTML_TEXT;
        return saw_text || (saw_any && lexer->lookahead == '#');
    }

    // `>` only ends a tag when the parser is actually inside one, which it
    // signals by making a closing delimiter valid. Anywhere else — `<p>a > b</p>`,
    // `#ratio#% ==>` — it is ordinary text.
    bool tag_delimiter_expected =
        VS(valid_symbols, CLOSE_TAG_DELIM, count) ||
        VS(valid_symbols, CLOSE_CF_TAG_DELIM, count) ||
        VS(valid_symbols, SELF_CLOSING_TAG_DELIMITER, count) ||
        VS(valid_symbols, CF_SELF_CLOSING_TAG_DELIMITER, count) ||
        VS(valid_symbols, CF_SELF_CLOSING_VOID_TAG_DELIMITER, count);

    while (lexer->lookahead != 0 && lexer->lookahead != '{' &&
           lexer->lookahead != '}' && lexer->lookahead != '#') {
        if (lexer->lookahead == '<') {
            // Peeking past `<` consumes it, and this scanner cannot rewind: if
            // the function then returns false the dispatcher below is left
            // looking at the character *after* the `<` and never sees the tag or
            // comment. Only peek once some text has been collected, which
            // guarantees a `true` return; a `<` at the very start of a text run
            // is left to the tag rules as before.
            if (!saw_text) {
                break;
            }
            // A `<` starts a tag only when a name, `/`, `!`, `?` or a dynamic
            // `#name#` can follow it. `5 < 6` is text, the same rule browsers
            // apply. mark_end first: on a real tag the token has to end here.
            lexer->mark_end(lexer);
            advance(lexer);
            if (lexer->lookahead == 0 || cf_isalpha(lexer->lookahead) || lexer->lookahead == '/' ||
                lexer->lookahead == '!' || lexer->lookahead == '?' || lexer->lookahead == '#') {
                break;
            }
            saw_text = true;
            saw_any = true;
            lexer->mark_end(lexer);
            continue;
        }
        if (lexer->lookahead == '>') {
            if (tag_delimiter_expected) {
                break;
            }
            advance(lexer);
            saw_text = true;
            saw_any = true;
            lexer->mark_end(lexer);
            continue;
        }
        if (lexer->lookahead == '&') {
            // Peek ahead to determine if this is an entity
            lexer->mark_end(lexer);
            advance(lexer);
            if (lexer->lookahead == '#') {
                // Could be numeric entity (&#digits; or &#xhex;) or &# followed by CFML hash
                // Mark end after & so it's consumed as text
                lexer->mark_end(lexer);
                saw_text = true;
                saw_any = true;
                advance(lexer);
                if (lexer->lookahead == 'x' || lexer->lookahead == 'X' || cf_isdigit(lexer->lookahead)) {
                    // Numeric entity - consume fully as text
                    if (lexer->lookahead == 'x' || lexer->lookahead == 'X') {
                        advance(lexer);
                        while (cf_isxdigit(lexer->lookahead)) advance(lexer);
                    } else {
                        while (cf_isdigit(lexer->lookahead)) advance(lexer);
                    }
                    if (lexer->lookahead == ';') advance(lexer);
                    lexer->mark_end(lexer);
                    continue;
                }
                // &# not followed by digit/x - & consumed as text, break at #
                break;
            }
            if (cf_isalpha(lexer->lookahead)) {
                // Could be &word; - scan ahead for ;
                unsigned count = 0;
                while (cf_isalpha(lexer->lookahead) && count < 31) {
                    advance(lexer);
                    count++;
                }
                if (lexer->lookahead == ';' && count > 0) {
                    // Valid entity pattern - stop before &
                    break;
                }
                // Not a valid entity - consume as text
                lexer->mark_end(lexer);
                saw_text = true;
                saw_any = true;
                continue;
            }
            // & followed by non-alpha, non-# - consume as text
            lexer->mark_end(lexer);
            saw_text = true;
            saw_any = true;
            continue;
        }
        bool is_wspace = cf_isspace(lexer->lookahead);
        if (lexer->lookahead == '\n') {
            at_newline = true;
        } else {
            at_newline &= is_wspace;
            if (!at_newline) {
                saw_text = true;
            }
        }
        saw_any = true;
        advance(lexer);
        lexer->mark_end(lexer);
    }

    lexer->result_symbol = HTML_TEXT;
    // Emit whitespace-only content when the next char is '#' so the parser
    // advances to a state where hash tokens become valid.
    return saw_text || (saw_any && lexer->lookahead == '#');
}


static bool scan_script_comment(TSLexer *lexer, bool is_cfquery_context) {

    for (;;) {

        if (lexer->lookahead == '/') {
            skip(lexer);
            while (lexer->lookahead != 0 && lexer->lookahead != '\n' && lexer->lookahead != 0x2028 &&
                    lexer->lookahead != 0x2029) {
                skip(lexer);
            }
            //*scanned_comment = true;
        } else if (lexer->lookahead == '*') {
            skip(lexer);
            while (lexer->lookahead != 0) {
                if (lexer->lookahead == '*') {
                    skip(lexer);
                    if (lexer->lookahead == '/') {
                        skip(lexer);
                        //*scanned_comment = true;
                        break;
                    }
                } else {
                    skip(lexer);
                }
            }
        } else {
            return false;
        }
    }
}


static bool scan_cfquery_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {

    if (scanner->cf_tags.size == 0) {
        return false;
    }

    Tag *cf_tag = array_back(&scanner->cf_tags);
    if (cf_tag->type != CF_QUERY) {
        return false;
    }

    lexer->mark_end(lexer);

    size_t tag_len = cf_tag->tag_name.size;
    if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;

    char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
    memcpy(end_delimiter, "</CF", 4);
    memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
    end_delimiter[4 + tag_len] = '\0';

    size_t delimiter_index = 0;
    size_t end_delim_len = 4 + tag_len;

    while (lexer->lookahead) {
        if (cf_toupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
            delimiter_index++;
            if (delimiter_index == end_delim_len) {
                break;
            }
            advance(lexer);
        } else {
            delimiter_index = 0;
            advance(lexer);
            lexer->mark_end(lexer);
        }
    }

    lexer->result_symbol = CF_QUERY_CONTENT;
    return true;
}

static bool scan_cfxml_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {

    if (scanner->cf_tags.size == 0) {
        return false;
    }

    Tag *cf_tag = array_back(&scanner->cf_tags);
    if (cf_tag->type != CF_XML) {
        return false;
    }

    lexer->mark_end(lexer);

    size_t tag_len = cf_tag->tag_name.size;
    if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;

    char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
    memcpy(end_delimiter, "</CF", 4);
    memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
    end_delimiter[4 + tag_len] = '\0';

    size_t delimiter_index = 0;
    size_t end_delim_len = 4 + tag_len;

    while (lexer->lookahead) {
        if (cf_toupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
            delimiter_index++;
            if (delimiter_index == end_delim_len) {
                break;
            }
            advance(lexer);
        } else {
            delimiter_index = 0;
            advance(lexer);
            lexer->mark_end(lexer);
        }
    }

    lexer->result_symbol = CF_XML_CONTENT;
    return true;
}


static bool scan_cfscript_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {

    if (scanner->cf_tags.size == 0) {
        return false;
    }

    Tag *cf_tag = array_back(&scanner->cf_tags);
    if (cf_tag->type != CF_SCRIPT) {
        return false;
    }

    lexer->mark_end(lexer);

    size_t tag_len = cf_tag->tag_name.size;
    if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;

    char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
    memcpy(end_delimiter, "</CF", 4);
    memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
    end_delimiter[4 + tag_len] = '\0';

    size_t delimiter_index = 0;
    size_t end_delim_len = 4 + tag_len;

    while (lexer->lookahead) {
        if (cf_toupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
            delimiter_index++;
            if (delimiter_index == end_delim_len) {
                break;
            }
            advance(lexer);
        } else {
            delimiter_index = 0;
            advance(lexer);
            lexer->mark_end(lexer);
        }
    }

    lexer->result_symbol = CF_SCRIPT_CONTENT;
    return true;
}

static bool scan_cfsavecontent_body_type(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols, unsigned count, bool is_cfquery_context) {
    if (scanner->cf_tags.size == 0) return false;
    Tag *cf_tag = array_back(&scanner->cf_tags);
    if (cf_tag->type != CF_SAVECONTENT) return false;

    // Default to cfml
    unsigned result = CF_SAVECONTENT_BODY_CFML;

    // Mark end at current position - this is a zero-width token
    lexer->mark_end(lexer);

    // Peek ahead for <!--- @content TYPE --->
    // Skip whitespace first
    while (cf_isspace(lexer->lookahead)) advance(lexer);

    if (lexer->lookahead == '<') {
        advance(lexer);
        if (lexer->lookahead == '!') {
            advance(lexer);
            if (lexer->lookahead == '-') {
                advance(lexer);
                if (lexer->lookahead == '-') {
                    advance(lexer);
                    if (lexer->lookahead == '-') {
                        advance(lexer);
                        // Skip whitespace after <!---
                        while (cf_isspace(lexer->lookahead)) advance(lexer);
                        // Check for @content
                        const char *directive = "@content";
                        size_t di = 0;
                        bool matched = true;
                        while (di < 8) {
                            if (lexer->lookahead != directive[di]) { matched = false; break; }
                            advance(lexer);
                            di++;
                        }
                        if (matched) {
                            // Skip whitespace
                            while (cf_isspace(lexer->lookahead)) advance(lexer);
                            // Read type word
                            char type_buf[16];
                            int len = 0;
                            while (cf_isalpha(lexer->lookahead) && len < 15) {
                                type_buf[len++] = cf_tolower(lexer->lookahead);
                                advance(lexer);
                            }
                            type_buf[len] = '\0';
                            if (strcmp(type_buf, "script") == 0) result = CF_SAVECONTENT_BODY_SCRIPT;
                            else if (strcmp(type_buf, "css") == 0) result = CF_SAVECONTENT_BODY_CSS;
                            else if (strcmp(type_buf, "xml") == 0) result = CF_SAVECONTENT_BODY_XML;
                            else if (strcmp(type_buf, "sql") == 0) result = CF_SAVECONTENT_BODY_SQL;
                            else if (strcmp(type_buf, "raw") == 0) result = CF_SAVECONTENT_BODY_RAW;
                            else if (strcmp(type_buf, "html") == 0) result = CF_SAVECONTENT_BODY_HTML;
                        }
                    }
                }
            }
        }
    }

    if (!VS(valid_symbols, result, count)) return false;
    lexer->result_symbol = result;
    return true;
}

static bool scan_cfsavecontent_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
    if (scanner->cf_tags.size == 0) return false;
    Tag *cf_tag = array_back(&scanner->cf_tags);
    if (cf_tag->type != CF_SAVECONTENT) return false;

    lexer->mark_end(lexer);

    size_t tag_len = cf_tag->tag_name.size;
    if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;

    char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
    memcpy(end_delimiter, "</CF", 4);
    memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
    end_delimiter[4 + tag_len] = '\0';
    size_t end_delim_len = 4 + tag_len;

    bool has_content = false;

    while (lexer->lookahead) {
        if (lexer->lookahead == '<') {
            lexer->mark_end(lexer);
            advance(lexer);
            if (lexer->lookahead == '/') {
                advance(lexer);
                size_t i = 2;
                bool matched = true;
                while (i < end_delim_len) {
                    if (cf_toupper(lexer->lookahead) != end_delimiter[i]) { matched = false; break; }
                    i++;
                    if (i < end_delim_len) advance(lexer);
                }
                if (matched) {
                    lexer->result_symbol = CF_SAVECONTENT_CONTENT;
                    return has_content;
                }
            }
            has_content = true;
            lexer->mark_end(lexer);
        } else {
            has_content = true;
            advance(lexer);
            lexer->mark_end(lexer);
        }
    }

    lexer->result_symbol = CF_SAVECONTENT_CONTENT;
    return has_content;
}

static bool scan_raw_text(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
    if (scanner->tags.size == 0) {
        return false;
    }

    lexer->mark_end(lexer);

    const char *end_delimiter = array_back(&scanner->tags)->type == SCRIPT ? "</SCRIPT" : "</STYLE";
    // Both delimiters are literals, but the compiler cannot fold a `strlen` of
    // the ternary's result, so it was running one per matching character.
    const unsigned end_delimiter_len = array_back(&scanner->tags)->type == SCRIPT ? 8 : 7;

    bool stop_at_cfml = !is_cfquery_context &&
        (array_back(&scanner->tags)->type == SCRIPT || array_back(&scanner->tags)->type == STYLE);

    bool has_content = false;
    unsigned delimiter_index = 0;
    while (lexer->lookahead) {
        // CFML boundary checks (only when not mid-delimiter match)
        if (stop_at_cfml && delimiter_index == 0) {
            if (lexer->lookahead == '#' && scanner->cfoutput_depth > 0) {
                break;
            }
            if (lexer->lookahead == '<') {
                advance(lexer);
                if (cf_toupper(lexer->lookahead) == 'C') {
                    advance(lexer);
                    if (cf_toupper(lexer->lookahead) == 'F') {
                        // Stop before <cf
                        break;
                    }
                    lexer->mark_end(lexer);
                    has_content = true;
                    continue;
                } else if (lexer->lookahead == '/') {
                    advance(lexer);
                    if (cf_toupper(lexer->lookahead) == 'C') {
                        advance(lexer);
                        if (cf_toupper(lexer->lookahead) == 'F') {
                            // Stop before </cf
                            break;
                        }
                        lexer->mark_end(lexer);
                        has_content = true;
                        continue;
                    } else if (cf_toupper(lexer->lookahead) == end_delimiter[2]) {
                        // Potential </script or </style
                        delimiter_index = 3;
                        advance(lexer);
                        continue;
                    }
                    lexer->mark_end(lexer);
                    has_content = true;
                    continue;
                } else if (lexer->lookahead == '!') {
                    // A CFML comment is stripped by the engine before anything
                    // inside it is evaluated, so a `#` in there never starts a
                    // hash expression. Swallow the whole comment as raw text so
                    // the `#` in `<!--- see http://x/#anchor --->` cannot open
                    // one. Extras are not reachable inside a script element, so
                    // it cannot be tokenised as a comment node here.
                    advance(lexer);
                    if (lexer->lookahead == '-') {
                        advance(lexer);
                        if (lexer->lookahead == '-') {
                            advance(lexer);
                            if (lexer->lookahead == '-') {
                                skip_cfml_comment_body(lexer);
                                lexer->mark_end(lexer);
                                has_content = true;
                                continue;
                            }
                        }
                    }
                    lexer->mark_end(lexer);
                    has_content = true;
                    continue;
                } else {
                    lexer->mark_end(lexer);
                    has_content = true;
                    continue;
                }
            }
        }

        if (cf_toupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
            delimiter_index++;
            if (delimiter_index == end_delimiter_len) {
                break;
            }
            advance(lexer);
        } else {
            delimiter_index = 0;
            advance(lexer);
            lexer->mark_end(lexer);
            has_content = true;
        }
    }

    if (!has_content) {
        return false;
    }

    lexer->result_symbol = RAW_TEXT;
    return true;
}

static void pop_tag(Scanner *scanner, bool is_cf_context) {
    if ( is_cf_context ) {
        Tag popped_tag = array_pop(&scanner->cf_tags);
        tag_free(&popped_tag);
    } else {
        Tag popped_tag = array_pop(&scanner->tags);
        tag_free(&popped_tag);
    }
}

static bool scan_implicit_end_tag(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context, bool from_tag_open) {

    Tag *parent = is_cf_context
        ? (scanner->cf_tags.size == 0 ? NULL : array_back(&scanner->cf_tags))
        : (scanner->tags.size == 0 ? NULL : array_back(&scanner->tags));

    bool is_closing_tag = false;
    if (lexer->lookahead == '/') {
        is_closing_tag = true;
        advance(lexer);
    } else {
        // Void tag processing
        if (!is_cf_context && parent && tag_is_void(parent)) {
            pop_tag(scanner, false);
            lexer->result_symbol = IMPLICIT_END_TAG;
            return true;
        }
        // Void tag processing
        if (is_cf_context && parent && cf_tag_is_void(parent)) {
            pop_tag(scanner, true);
            lexer->result_symbol = IMPLICIT_CF_END_TAG;
            return true;
        }
    }

    TagNameResult result = scan_tag_name(lexer, is_cfquery_context);
    if (result.tag_name.size == 0 && !lexer->eof(lexer)) {
        array_delete(&result.tag_name);
        return false;
    }

    if (result.is_cf_tag && !is_closing_tag &&
        ((result.tag_name.size == 4 && memcmp(result.tag_name.contents, "ELSE", 4) == 0) ||
         (result.tag_name.size == 6 && memcmp(result.tag_name.contents, "ELSEIF", 6) == 0))) {
        array_delete(&result.tag_name);
        if (is_cf_context && parent &&
            parent->type != CF_IF && parent->type != CF_ELSEIF && parent->type != CF_ELSE) {
            pop_tag(scanner, true);
            lexer->result_symbol = IMPLICIT_CF_END_TAG;
            return true;
        }
        if (!is_cf_context && scanner->tags.size > 0) {
            // Check if there's a CF_IF on the cf_tags stack whose html_depth
            // is less than current tags.size (meaning HTML tags opened inside cfif)
            for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
                Tag *ct = &scanner->cf_tags.contents[i - 1];
                if (ct->type == CF_IF || ct->type == CF_ELSEIF || ct->type == CF_ELSE) {
                    if (scanner->tags.size > ct->html_depth) {
                        pop_tag(scanner, false);
                        lexer->result_symbol = IMPLICIT_END_TAG;
                        return true;
                    }
                    break;
                }
            }
        }
        return false;
    }

    if (result.is_cf_tag && !is_cf_context && is_closing_tag) {
        // A CF closing tag in HTML context: only implicitly close HTML tags
        // that were opened inside this CF tag (i.e. tags.size > cf html_depth)
        Tag cf_next = cf_tag_for_name(result.tag_name);
        unsigned cf_html_depth = 0;
        bool found = false;
        for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
            if (tag_eq(&scanner->cf_tags.contents[i - 1], &cf_next)) {
                cf_html_depth = scanner->cf_tags.contents[i - 1].html_depth;
                found = true;
                break;
            }
        }
        tag_free(&cf_next);
        if (found && scanner->tags.size > cf_html_depth) {
            pop_tag(scanner, false);
            lexer->result_symbol = IMPLICIT_END_TAG;
            return true;
        }
        return false;
    }

    if (result.is_cf_tag && !is_cf_context) {
        array_delete(&result.tag_name);
        return false;
    }


    Tag next_tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);

    if (is_closing_tag) {
        // The tag correctly closes the topmost element on the stack
        if (is_cf_context ? (scanner->cf_tags.size > 0 && tag_eq(array_back(&scanner->cf_tags), &next_tag))
                          : (scanner->tags.size > 0 && tag_eq(array_back(&scanner->tags), &next_tag))) {
            // Before accepting the CF close, check if HTML tags opened inside
            // this CF tag need implicit closing (e.g. <cfloop><span></cfloop>)
            if (is_cf_context && scanner->tags.size > array_back(&scanner->cf_tags)->html_depth) {
                pop_tag(scanner, false);
                lexer->result_symbol = IMPLICIT_END_TAG;
                tag_free(&next_tag);
                return true;
            }
            tag_free(&next_tag);
            return false;
        }

        // if (is_cf ? (scanner->cf_tags.size > 0 && !tag_eq(array_back(&scanner->cf_tags), &next_tag))
        //                   : (scanner->tags.size > 0 && !tag_eq(array_back(&scanner->tags), &next_tag))) {
        //     pop_tag(scanner, is_cf);
        //     lexer->result_symbol = is_cf ? IMPLICIT_CF_END_TAG : IMPLICIT_END_TAG;
        //     tag_free(&next_tag);
        //     return true;
        // }

        // Otherwise, dig deeper and queue implicit end tags (to be nice in
        // the case of malformed HTML)
        if (is_cf_context) {
            for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
                if (tag_eq(&scanner->cf_tags.contents[i - 1], &next_tag)) {
                    pop_tag(scanner, true);
                    lexer->result_symbol = IMPLICIT_CF_END_TAG;
                    tag_free(&next_tag);
                    return true;
                }
            }
        } else {
            for (unsigned i = scanner->tags.size; i > 0; i--) {
                if (tag_eq(&scanner->tags.contents[i - 1], &next_tag)) {
                    pop_tag(scanner, false);
                    lexer->result_symbol = IMPLICIT_END_TAG;
                    tag_free(&next_tag);
                    return true;
                }
            }
        }
    } else {

        if (from_tag_open && is_cf_context && !result.is_cf_tag && parent && tag_eq(parent, &next_tag)) {
            pop_tag(scanner, true);
            lexer->result_symbol = IMPLICIT_CF_END_TAG;
            tag_free(&next_tag);
            return true;
        }

        if (!is_cf_context && parent && tag_eq(parent, &next_tag) && tag_implicitly_closes_self(parent)) {
            pop_tag(scanner, false);
            lexer->result_symbol = IMPLICIT_END_TAG;
            tag_free(&next_tag);
            return true;
        }

        if (
            parent &&
            (
                (lexer->eof(lexer))
                || (is_cf_context && lexer->eof(lexer))
            )
        ) {
            pop_tag(scanner, is_cf_context);
            lexer->result_symbol = is_cf_context ? IMPLICIT_CF_END_TAG : IMPLICIT_END_TAG;
            tag_free(&next_tag);
            return true;
        }
    }

    tag_free(&next_tag);
    return false;
}

static bool scan_start_tag_name(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {

    // Dynamic tag name: <#expression#>
    if (lexer->lookahead == '#') {
        Tag tag = tag_new();
        tag.type = DYNAMIC;
        array_push(&scanner->tags, tag);
        lexer->result_symbol = START_TAG_NAME;
        return true;
    }

    TagNameResult result = scan_tag_name(lexer, is_cfquery_context);

    if (result.tag_name.size == 0) {
        array_delete(&result.tag_name);
        return false;
    }

    if ( result.is_cf_tag && !is_cf_context ) {
        array_delete(&result.tag_name);
        return false;
    }

    // bool is_cf = result.is_cf_tag || is_cf_context;
    Tag tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);

    // printf("scan_start_tag_name: tag=%.*s, is_cf_tag=%d, is_cf_context=%d, type=%d\n",
    // (int)result.tag_name.size, result.tag_name.contents, result.is_cf_tag, is_cf_context, tag.type);

    switch (tag.type) {
        case SCRIPT:
            lexer->result_symbol = SCRIPT_START_TAG_NAME;
            break;
        case STYLE:
            lexer->result_symbol = STYLE_START_TAG_NAME;
            break;
        case CF_VOID:
            if (is_cf_context && tag.tag_name.size == 9 &&
                memcmp(tag.tag_name.contents, "COMPONENT", 9) == 0) {
                scanner->cfcomponent_depth++;
                lexer->result_symbol = CF_COMPONENT_START_TAG_NAME;
            } else {
                lexer->result_symbol = CF_VOID_START_TAG_NAME;
            }
            tag_free(&tag);
            return true;
        case CF_SET:
            lexer->result_symbol = CF_SET_START_TAG_NAME;
            return true;
        case CF_RETURN:
            lexer->result_symbol = CF_RETURN_START_TAG_NAME;
            return true;
        case CF_IF:
            lexer->result_symbol = CF_IF_START_TAG_NAME;
            break;
        case CF_ELSEIF:
            lexer->result_symbol = CF_ELSEIF_TAG_NAME;
            return true;
        case CF_ELSE:
            lexer->result_symbol = CF_ELSE_TAG_NAME;
            return true;
        case CF_XML:
            lexer->result_symbol = CF_XML_START_TAG_NAME;
            break;
        case CF_QUERY:
            lexer->result_symbol = CF_QUERY_START_TAG_NAME;
            break;
        case CF_SCRIPT:
            lexer->result_symbol = CF_SCRIPT_START_TAG_NAME;
            break;
         case CF_SAVECONTENT:
            lexer->result_symbol = CF_SAVECONTENT_START_TAG_NAME;
            break;
        case CF_OUTPUT:
            lexer->result_symbol = CF_OUTPUT_START_TAG_NAME;
            if (is_cf_context) {
                scanner->cfoutput_depth++;
            }
            break;
        case CF_FUNCTION:
            lexer->result_symbol = CF_FUNCTION_START_TAG_NAME;
            if (is_cf_context) {
                scanner->cffunction_depth++;
            }
            break;
        default:
            lexer->result_symbol = is_cf_context ? CF_START_TAG_NAME : START_TAG_NAME;
            break;
    }

    // A custom tag whose push would break the serialize/deserialize round trip
    // does not nest. `CFML` is the type `cf_tag_for_name` gives an unrecognised
    // `<cf_foo>` — `CUSTOM` is the HTML-side type and never reaches here. `CUSTOM` only, and deliberately: the cases above this point
    // that reach the push also bump a depth counter (`cfoutput`, `cffunction`,
    // `cfcomponent`), so bailing out here would leave the counter incremented
    // for a tag that was never pushed. A `<cf_foo>` run is the shape that
    // actually reaches ~1KB of stack, and `CF_VOID_START_TAG_NAME` completes
    // such an element without an end tag — the same symbol the void tags in
    // `CF_VOID_TAGS` use, so no new grammar rule is needed.
    //
    // The tag stops nesting rather than the document being lost. Whether an
    // unpaired custom tag should nest AT ALL is the open question on #55; this
    // does not settle it, it stops the failure being unrecoverable.
    if (is_cf_context && tag.type == CFML &&
        tag_stack_would_overflow(scanner, &tag, is_cfquery_context)) {
        lexer->result_symbol = CF_VOID_START_TAG_NAME;
        tag_free(&tag);
        return true;
    }

    if ( is_cf_context ) {
        tag.html_depth = scanner->tags.size;
        array_push(&scanner->cf_tags, tag);
    } else {
        array_push(&scanner->tags, tag);
    }

    return true;
}

static void set_end_tag_symbol(Scanner *scanner, TSLexer *lexer, Tag *tag, bool is_cf_context, bool is_cfquery_context) {
    if (is_cf_context && tag->type == CF_OUTPUT) {
        if (scanner->cfoutput_depth > 0) scanner->cfoutput_depth--;
        lexer->result_symbol = CF_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_FUNCTION) {
        if (scanner->cffunction_depth > 0) scanner->cffunction_depth--;
        lexer->result_symbol = CF_FUNCTION_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_XML) {
        lexer->result_symbol = CF_XML_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_QUERY) {
        lexer->result_symbol = CF_QUERY_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_SCRIPT) {
        lexer->result_symbol = CF_SCRIPT_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_SAVECONTENT) {
        lexer->result_symbol = CF_SAVECONTENT_END_TAG_NAME;
    } else if (is_cf_context && tag->type == CF_IF) {
        lexer->result_symbol = CF_IF_END_TAG_NAME;
    } else {
        lexer->result_symbol = is_cf_context ? CF_END_TAG_NAME : END_TAG_NAME;
    }
}

static bool scan_end_tag_name(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {

    // Dynamic closing tag: </#expression#>
    if (lexer->lookahead == '#') {
        if (scanner->tags.size > 0 && array_back(&scanner->tags)->type == DYNAMIC) {
            pop_tag(scanner, false);
        }
        lexer->result_symbol = END_TAG_NAME;
        return true;
    }

    TagNameResult result = scan_tag_name(lexer, is_cfquery_context);

    if (result.tag_name.size == 0) {
        array_delete(&result.tag_name);
        return false;
    }

    if ( result.is_cf_tag && !is_cf_context ) {
        array_delete(&result.tag_name);
        return false;
    }

    // printf("scan_end_tag_name: tag=%.*s, is_cf_context=%d, tags.size=%d, cf_tags.size=%d\n",
    // (int)result.tag_name.size, result.tag_name.contents, is_cf_context,
    // scanner->tags.size, scanner->cf_tags.size);

    // bool is_cf = result.is_cf_tag || is_cf_context;

    Tag tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);

    // cfcomponent is a void tag (never pushed); just decrement depth
    if (is_cf_context && tag.type == CF_VOID &&
        tag.tag_name.size == 9 && memcmp(tag.tag_name.contents, "COMPONENT", 9) == 0) {
        if (scanner->cfcomponent_depth > 0) scanner->cfcomponent_depth--;
        lexer->result_symbol = CF_COMPONENT_END_TAG_NAME;
        tag_free(&tag);
        return true;
    }

    // Determine the minimum HTML stack index we can search to.
    // CF control-flow tags record html_depth when pushed; don't search below that.
    unsigned html_floor = 0;
    if (!is_cf_context && scanner->cf_tags.size > 0) {
        html_floor = array_back(&scanner->cf_tags)->html_depth;
    }

    Tag *tag_back = (is_cf_context) ? ( scanner->cf_tags.size > 0 ? array_back(&scanner->cf_tags) : NULL )
                   : ( scanner->tags.size > html_floor) ? array_back(&scanner->tags) : NULL;

    if ( tag_back && tag_eq(tag_back, &tag) ) {
        pop_tag(scanner, is_cf_context);
        set_end_tag_symbol(scanner, lexer, &tag, is_cf_context, is_cfquery_context);
    } else {
        // Search deeper in the stack for a matching tag
        bool found = false;
        if (is_cf_context) {
            for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
                if (tag_eq(&scanner->cf_tags.contents[i - 1], &tag)) {
                    found = true;
                    break;
                }
            }
        } else {
            for (unsigned i = scanner->tags.size; i > html_floor; i--) {
                if (tag_eq(&scanner->tags.contents[i - 1], &tag)) {
                    found = true;
                    break;
                }
            }
        }

        if (found) {
            pop_tag(scanner, is_cf_context);
            set_end_tag_symbol(scanner, lexer, &tag, is_cf_context, is_cfquery_context);
        } else {
            lexer->result_symbol = is_cf_context ? ERRONEOUS_CF_END_TAG_NAME : ERRONEOUS_END_TAG_NAME;
        }
    }

    tag_free(&tag);
    return true;
}

static bool scan_cf_self_closing_tag_delimiter(Scanner *scanner, TSLexer *lexer, bool is_void, bool is_cfquery_context) {
     if (lexer->lookahead == '>') {
        advance(lexer);
        if (is_void) {
            lexer->result_symbol = CF_SELF_CLOSING_VOID_TAG_DELIMITER;
        } else {
            lexer->result_symbol = CF_SELF_CLOSING_TAG_DELIMITER;
            if (scanner->cf_tags.size > 0) {
                pop_tag(scanner, true);
            }

        }
        return true;
    }
    return false;
}

static bool scan_self_closing_tag_delimiter(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
     if (lexer->lookahead == '>') {
        advance(lexer);
        if (scanner->tags.size > 0) {
            pop_tag(scanner, false);
        }
        lexer->result_symbol = SELF_CLOSING_TAG_DELIMITER;
        return true;
    }
    return false;
}

// Check if the current position matches a CFML word operator (case-insensitive).
static bool scan_cfml_word_operator(TSLexer *lexer) {
    char buf[11] = {0};
    int len = 0;
    for (; len < 10 && cf_isalpha(lexer->lookahead); len++) {
        buf[len] = cf_tolower(lexer->lookahead);
        skip(lexer);
    }
    bool at_end = !cf_isalnum(lexer->lookahead);
    if (!at_end) return false;

    return (len == 2 && (
        (buf[0] == 'o' && buf[1] == 'r') ||
        (buf[0] == 'e' && buf[1] == 'q') ||
        (buf[0] == 'g' && buf[1] == 't') ||
        (buf[0] == 'g' && buf[1] == 'e') ||
        (buf[0] == 'l' && buf[1] == 't') ||
        (buf[0] == 'l' && buf[1] == 'e') ||
        (buf[0] == 'i' && buf[1] == 'n')
    )) || (len == 3 && (
        (buf[0] == 'a' && buf[1] == 'n' && buf[2] == 'd') ||
        (buf[0] == 'n' && buf[1] == 'e' && buf[2] == 'q') ||
        (buf[0] == 'n' && buf[1] == 'o' && buf[2] == 't') ||
        (buf[0] == 'g' && buf[1] == 't' && buf[2] == 'e') ||
        (buf[0] == 'l' && buf[1] == 't' && buf[2] == 'e') ||
        (buf[0] == 'm' && buf[1] == 'o' && buf[2] == 'd')
    )) || (len == 10 &&
        buf[0] == 'i' && buf[1] == 'n' && buf[2] == 's' && buf[3] == 't' &&
        buf[4] == 'a' && buf[5] == 'n' && buf[6] == 'c' && buf[7] == 'e' &&
        buf[8] == 'o' && buf[9] == 'f'
    );
}

static bool scan_automatic_semicolon(TSLexer *lexer, bool comment_condition, bool *scanned_comment, bool is_cfquery_context) {
    lexer->result_symbol = AUTOMATIC_SEMICOLON;
    lexer->mark_end(lexer);

    for (;;) {
        if (lexer->lookahead == 0) {
            return true;
        }

        if (lexer->lookahead == '/') {
            WhitespaceResult result = scan_whitespace_and_comments(lexer, scanned_comment, false, is_cfquery_context);
            if (result == false) {
                return false;
            }
            if (result == true && comment_condition && lexer->lookahead != ',' && lexer->lookahead != '=') {
                return true;
            }
        }

        if (lexer->lookahead == '}') {
            return true;
        }

        if (lexer->is_at_included_range_start(lexer)) {
            return true;
        }

        if (lexer->lookahead == '\n' || lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
            break;
        }

        if (!cf_isspace(lexer->lookahead)) {
            return false;
        }

        skip(lexer);
    }

    skip(lexer);

    if (scan_whitespace_and_comments(lexer, scanned_comment, true, is_cfquery_context) == REJECT) {
        return false;
    }

    switch (lexer->lookahead) {
        case '`':
        case ',':
        case ':':
        case ';':
        case '*':
        case '%':
        case '>':
        case '<':
        case '=':
        case '[':
        case '(':
        case '?':
        case '^':
        case '|':
        case '&':
        case '/':
            return false;

        // Insert a semicolon before decimals literals but not otherwise.
        case '.':
            skip(lexer);
            return cf_isdigit(lexer->lookahead);

        // Insert a semicolon before `--` and `++`, but not before binary `+` or `-`.
        case '+':
            skip(lexer);
            return lexer->lookahead == '+';
        case '-':
            skip(lexer);
            return lexer->lookahead == '-';

        // Don't insert a semicolon before `!=`, but do insert one before a unary `!`.
        case '!':
            skip(lexer);
            return lexer->lookahead != '=';

        // Don't insert a semicolon before CFML word operators
        // (and, or, eq, neq, not, gt, gte, ge, lt, lte, le, mod, in, instanceof)
        case 'i':
        case 'a': case 'A':
        case 'o': case 'O':
        case 'e': case 'E':
        case 'n': case 'N':
        case 'g': case 'G':
        case 'l': case 'L':
        case 'm': case 'M':
            return !scan_cfml_word_operator(lexer);

        default:
            break;
    }

    return true;
}

static bool scan_ternary_qmark(TSLexer *lexer, bool is_cfquery_context) {
    for (;;) {
        if (!cf_isspace(lexer->lookahead)) {
            break;
        }
        skip(lexer);
    }

    if (lexer->lookahead == '?') {
        advance(lexer);

        if (lexer->lookahead == ':') {

            advance(lexer);
            lexer->mark_end(lexer);
            lexer->result_symbol = ELVIS_OPERATOR;

            return true;

        } else if (lexer->lookahead == '?') {
            return false;
        }

        lexer->mark_end(lexer);
        lexer->result_symbol = TERNARY_QMARK;

        if (lexer->lookahead == '.') {
            advance(lexer);
            if (cf_isdigit(lexer->lookahead)) {
                return true;
            }
            return false;
        }
        return true;
    }
    return false;
}

static bool scan_closetag_delim(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {
    if ( lexer->lookahead == '>' ) {
        advance(lexer);
        lexer->mark_end(lexer);
        lexer->result_symbol = is_cf_context ? CLOSE_CF_TAG_DELIM : CLOSE_TAG_DELIM;
        return true;
    } else {
        return false;
    }
}

static bool scanner_in_hash_eval_context(Scanner *scanner, bool is_cfquery_context) {
    if (scanner->cfoutput_depth > 0 || scanner->cfcomponent_depth > 0 || scanner->cffunction_depth > 0) {
        return true;
    }
    return false;
}

static bool scan_cf_component_content(TSLexer *lexer, bool is_cfquery_context) {
    // Skip whitespace and script-style comments (// and /* */)
    for (;;) {
        while (cf_isspace(lexer->lookahead)) advance(lexer);
        if (lexer->lookahead == '/') {
            advance(lexer);
            if (lexer->lookahead == '/') {
                advance(lexer);
                while (lexer->lookahead != 0 && lexer->lookahead != '\n') advance(lexer);
            } else if (lexer->lookahead == '*') {
                advance(lexer);
                while (lexer->lookahead != 0) {
                    if (lexer->lookahead == '*') { advance(lexer); if (lexer->lookahead == '/') { advance(lexer); break; } }
                    else advance(lexer);
                }
            } else {
                return false;
            }
        } else {
            break;
        }
    }

    // Read the first word
    char word[16];
    int len = 0;
    while (cf_isalpha(lexer->lookahead) && len < 15) {
        word[len++] = cf_tolower(lexer->lookahead);
        advance(lexer);
    }
    word[len] = '\0';

    // Must not be followed by another identifier char (e.g. 'componentFoo')
    if (cf_isalnum(lexer->lookahead) || lexer->lookahead == '_') return false;

    // If the word is a modifier, skip whitespace and read the next one.
    //
    // `final` was missing from this set, which is what made a `.cfc` starting
    // `final component` fall through to `html_text` instead of being recognised
    // as a component file — a silent degradation rather than an ERROR, so every
    // consumer believed it had a valid parse of a text file.
    //
    // Looped rather than done once because Lucee accepts more than one modifier
    // (`final abstract component`). The loop terminates because each iteration
    // either consumes a word or reads none, and an empty word matches no
    // modifier.
    while (strcmp(word, "abstract") == 0 || strcmp(word, "static") == 0
            || strcmp(word, "final") == 0) {
        while (cf_isspace(lexer->lookahead)) advance(lexer);
        len = 0;
        while (cf_isalpha(lexer->lookahead) && len < 15) {
            word[len++] = cf_tolower(lexer->lookahead);
            advance(lexer);
        }
        word[len] = '\0';
        if (cf_isalnum(lexer->lookahead) || lexer->lookahead == '_') return false;
        if (len == 0) return false;
    }

    if (strcmp(word, "component") != 0 && strcmp(word, "property") != 0 &&
            strcmp(word, "interface") != 0 && strcmp(word, "import") != 0) {
        return false;
    }

    // Consume the rest of the file
    while (lexer->lookahead != 0) advance(lexer);
    lexer->mark_end(lexer);
    lexer->result_symbol = CF_COMPONENT_CONTENT;
    return true;
}

static bool external_scanner_scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols, unsigned count, bool is_cfquery_context) {

    if (!VS(valid_symbols, HTML_TEXT, count) && !VS(valid_symbols, RAW_TEXT, count)) {
        while (cf_isspace(lexer->lookahead)) {
            skip(lexer);
        }
    }

    if ((VS(valid_symbols, START_HASH_EXPRESSION, count) || VS(valid_symbols, SINGLE_HASH, count) || VS(valid_symbols, HASH_EMPTY, count))
            && !VS(valid_symbols, AUTOMATIC_SEMICOLON, count) && lexer->lookahead == '#') {
        advance(lexer);
        if (lexer->lookahead == '#') {
            advance(lexer);
            lexer->mark_end(lexer);
            lexer->result_symbol = HASH_EMPTY;
        } else if (scanner_in_hash_eval_context(scanner, is_cfquery_context)) {
            lexer->result_symbol = START_HASH_EXPRESSION;
        } else {
            lexer->mark_end(lexer);
            lexer->result_symbol = SINGLE_HASH;
        }
        return true;
    }

    if (VS(valid_symbols, CF_COMPONENT_CONTENT, count)
            && scanner->tags.size == 0 && scanner->cf_tags.size == 0
            && scan_cf_component_content(lexer, is_cfquery_context)) {
        return true;
    }

    if (VS(valid_symbols, RAW_TEXT, count) && !VS(valid_symbols, START_TAG_NAME, count) && !VS(valid_symbols, END_TAG_NAME, count)) {
        if (scan_raw_text(scanner, lexer, is_cfquery_context)) {
            return true;
        }
    }

    if (VS(valid_symbols, CF_XML_CONTENT, count)) {
        return scan_cfxml_content(scanner, lexer, is_cfquery_context);
    }

    if (VS(valid_symbols, CF_QUERY_CONTENT, count)) {
        return scan_cfquery_content(scanner, lexer, is_cfquery_context);
    }

    if (VS(valid_symbols, CF_SCRIPT_CONTENT, count)) {
        return scan_cfscript_content(scanner, lexer, is_cfquery_context);
    }

    if (VS(valid_symbols, CF_SAVECONTENT_BODY_CFML, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_HTML, count) ||
        VS(valid_symbols, CF_SAVECONTENT_BODY_SCRIPT, count) ||
        VS(valid_symbols, CF_SAVECONTENT_BODY_CSS, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_XML, count) ||
        VS(valid_symbols, CF_SAVECONTENT_BODY_SQL, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_RAW, count)) {
        if (scan_cfsavecontent_body_type(scanner, lexer, valid_symbols, count, is_cfquery_context)) {
            return true;
        }
    }

    if (VS(valid_symbols, CF_SAVECONTENT_CONTENT, count)) {
        return scan_cfsavecontent_content(scanner, lexer, is_cfquery_context);
    }


    if (VS(valid_symbols, HTML_TEXT, count) && scan_html_text(scanner, lexer, is_cfquery_context, valid_symbols, count)) {
        return true;
    }

    switch (lexer->lookahead) {
        case ';':
            return false;
        break;
        case '<':
            lexer->mark_end(lexer);
            advance(lexer);

            if (VS(valid_symbols, CFML_COMMENT, count) && lexer->lookahead == '!') {
                advance(lexer);
                return scan_comment(lexer, is_cfquery_context);
            }

            if (implicit_cf_end_tag_valid(valid_symbols, count)) {
                return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, true);
            }

            if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
                return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, true);
            }

            break;

        case '\0':

            if (implicit_cf_end_tag_valid(valid_symbols, count)) {
                return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, true);
            }

            if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
                return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, true);
            }
            break;

        case '/':

            advance(lexer);
            if (lexer->lookahead == '>') {
                if (VS(valid_symbols, CF_SELF_CLOSING_TAG_DELIMITER, count)) {
                    return scan_cf_self_closing_tag_delimiter(scanner, lexer, false, is_cfquery_context);
                }
                if (VS(valid_symbols, CF_SELF_CLOSING_VOID_TAG_DELIMITER, count)) {
                    return scan_cf_self_closing_tag_delimiter(scanner, lexer, true, is_cfquery_context);
                }
                if (VS(valid_symbols, SELF_CLOSING_TAG_DELIMITER, count)) {
                    return scan_self_closing_tag_delimiter(scanner, lexer, is_cfquery_context);
                }
                if (VS(valid_symbols, CLOSE_CF_TAG_DELIM, count)) {
                    return scan_closetag_delim(scanner, lexer, true, is_cfquery_context);
                }
                if (VS(valid_symbols, CLOSE_TAG_DELIM, count)) {
                    return scan_closetag_delim(scanner, lexer, false, is_cfquery_context);
                }
            } else if (lexer->lookahead == '/' || lexer->lookahead == '*') {
                if (!scan_script_comment(lexer, is_cfquery_context)) {
                    return false;
                }
            }

            break;

        default:
            if (valid_start_tag_name(valid_symbols, count) && no_content_symbols(valid_symbols, count)) {
                return scan_start_tag_name(scanner, lexer, valid_cf_start_tag_name(valid_symbols, count), is_cfquery_context);
            }
            if (valid_end_tag_name(valid_symbols, count) && no_content_symbols(valid_symbols, count)) {
                return scan_end_tag_name(scanner, lexer, valid_cf_end_tag_name(valid_symbols, count), is_cfquery_context);
            }

            if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
                return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, false);
            } else if (VS(valid_symbols, IMPLICIT_CF_END_TAG, count)) {
                return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, false);
            }

            if (VS(valid_symbols, ERRONEOUS_END_TAG_NAME, count)) {
                return scan_end_tag_name(scanner, lexer, false, is_cfquery_context);
            } else if (VS(valid_symbols, ERRONEOUS_CF_END_TAG_NAME, count)) {
                return scan_end_tag_name(scanner, lexer, true, is_cfquery_context);
            }

            if (VS(valid_symbols, CF_COMPONENT_END_TAG_NAME, count)) {
                return scan_end_tag_name(scanner, lexer, true, is_cfquery_context);
            }

            if (VS(valid_symbols, CLOSE_CF_TAG_DELIM, count)) {
                if (scan_closetag_delim(scanner, lexer, true, is_cfquery_context)) {
                    return true;
                }
            }

            if (VS(valid_symbols, CLOSE_TAG_DELIM, count)) {
                if (scan_closetag_delim(scanner, lexer, false, is_cfquery_context)) {
                    return true;
                }
            }
    }

    if (VS(valid_symbols, AUTOMATIC_SEMICOLON, count)) {
        bool scanned_comment = false;
        bool ret = scan_automatic_semicolon(lexer, !VS(valid_symbols, LOGICAL_OR, count), &scanned_comment, is_cfquery_context);
        if (!ret && !scanned_comment && VS(valid_symbols, TERNARY_QMARK, count) && lexer->lookahead == '?') {
            return scan_ternary_qmark(lexer, is_cfquery_context);
        }
        return ret;
    }

    if (VS(valid_symbols, TERNARY_QMARK, count) || VS(valid_symbols, ELVIS_OPERATOR, count)) {
        return scan_ternary_qmark(lexer, is_cfquery_context);
    }

    return false;
}