tree-sitter-sed 0.7.0 → 0.9.0

package/common/scanner.h

@@ -21,10 +21,13 @@ enum TokenType {
   TRANSLATE_MIDDLE,
   TRANSLATE_END,
   REGEX_LITERAL,
+  INVALID_CHARACTER,
+  NUL_CHARACTER,
   REGEX_BEGINNING_ANCHOR,
   REGEX_END_ANCHOR,
   REGEX_PERIOD,
   REGEX_QUOTED_ESCAPE,
+  ESCAPE_PREFIX,
   REGEX_NEWLINE_ESCAPE,
   REGEX_ESCAPED_DELIMITER,
   REGEX_SPECIAL_ESCAPED_DELIMITER,
@@ -38,9 +41,6 @@ enum TokenType {
   REGEX_BRE_PLUS_ESCAPE,
   REGEX_BRE_SUBEXPRESSION_CARET,
   REGEX_BRE_SUBEXPRESSION_DOLLAR,
-  BRE_VERTICAL_LINE_ESCAPE_MARKER,
-  BRE_QUESTION_MARK_ESCAPE_MARKER,
-  BRE_PLUS_ESCAPE_MARKER,
   REGEX_UNMATCHED_INTERVAL_CLOSE,
 #endif
 #if SED_REGEX_EXTENDED
@@ -73,6 +73,7 @@ enum TokenType {
   REGEX_BRACKET_TRAILING_HYPHEN,
   REGEX_OPEN_COLON,
   REGEX_CLASS_NAME,
+  REGEX_INVALID_CLASS_NAME,
   REGEX_COLON_CLOSE,
   REGEX_OPEN_DOT,
   REGEX_COLL_ELEM_SINGLE,
@@ -110,6 +111,7 @@ enum TokenType {
   INVALID_SUBSTITUTION_FLAG,
   FLAG_AFTER_WRITE_MARKER,
   TEXT_COMMAND_START,
+  TEXT_INCOMPLETE_INTRODUCER,
   TEXT_LITERAL,
   TEXT_BACKSLASH_ESCAPE,
   TEXT_ESCAPED_NEWLINE,
@@ -120,8 +122,11 @@ enum TokenType {
   COMMENT_TEXT,
   FILE_ARGUMENT,
   SUBSTITUTION_WFILE_ARGUMENT,
+  SUBSTITUTION_WFILE_CONTINUATION,
   LINE_WORD,
+  ARGUMENT_SEPARATOR,
   RIGHT_BRACE,
+  EMPTY_COMMAND_MARKER,
   RESERVED_UNKNOWN_FUNCTION_TOKEN,
   REGEX_INCOMPLETE_GROUP,
   REGEX_INCOMPLETE_BRACKET_TERM,
@@ -187,24 +192,18 @@ enum RegexState {
   REGEX_BRACKET_BODY,
 };
 
-enum TextState {
-  TEXT_EMPTY,
-  TEXT_HAS_CONTENT,
-  TEXT_AFTER_ESCAPED_NEWLINE,
-};
-
-enum RegexIntervalState {
-  REGEX_INTERVAL_NONE,
-  REGEX_INTERVAL_EXPECT_MINIMUM,
-  REGEX_INTERVAL_AFTER_MINIMUM,
-  REGEX_INTERVAL_EXPECT_MAXIMUM,
-  REGEX_INTERVAL_AFTER_MAXIMUM,
-};
-
-enum RegexDuplicationState {
-  REGEX_DUPLICATION_NONE,
+enum RegexPosition {
+  REGEX_AFTER_ATOM,
+  REGEX_AT_BRANCH_START,
+#if SED_REGEX_EXTENDED
+  REGEX_AFTER_ALTERNATION,
+#else
+  REGEX_AFTER_ANCHOR,
+#endif
   REGEX_AFTER_DUPLICATION_SYMBOL,
+#if SED_REGEX_EXTENDED
   REGEX_AFTER_REPETITION_MODIFIER,
+#endif
 };
 
 enum RegexBracketTermState {
@@ -226,39 +225,31 @@ typedef struct {
   int32_t delimiter;
   enum ScannerMode mode;
   enum RegexState regex_state;
-  bool regex_at_branch_start;
-  enum RegexDuplicationState regex_duplication_state;
-  bool regex_after_alternation;
-  bool regex_after_anchor;
-  enum TextState text_state;
-  enum RegexIntervalState regex_interval_state;
+  enum RegexPosition regex_position;
+  bool text_line_has_content;
+  bool regex_in_interval;
   enum RegexBracketTermState regex_bracket_term_state;
+  bool regex_bracket_term_has_content;
   enum RegexBracketPendingElement regex_bracket_pending_element;
   enum RegexBracketPendingElement regex_bracket_first_element;
   enum RegexBracketPendingElement regex_bracket_last_element;
   uint8_t regex_bracket_element_count;
   bool regex_bracket_range_pending;
-  uint16_t regex_group_depth;
+  uint32_t regex_group_depth;
 } ScannerState;
 
-enum {
-  SCANNER_SERIALIZATION_VERSION = 14,
-  SCANNER_SERIALIZED_STATE_SIZE = 17,
-};
+enum { SCANNER_SERIALIZED_STATE_SIZE = 17 };
 
 enum {
-  SERIALIZED_AT_BRANCH_START_FLAG = 1 << 0,
-  SERIALIZED_AFTER_ALTERNATION_FLAG = 1 << 1,
-  SERIALIZED_AFTER_ANCHOR_FLAG = 1 << 2,
-  SERIALIZED_TEXT_STATE_SHIFT = 3,
-  SERIALIZED_MODE_FLAGS_MAXIMUM = 31,
-  SERIALIZED_RANGE_PENDING_FLAG = 1 << 0,
-  SERIALIZED_DUPLICATION_STATE_SHIFT = 1,
-  SERIALIZED_BRACKET_FLAGS_MAXIMUM = 7,
+  SERIALIZED_TEXT_HAS_CONTENT_FLAG = 1 << 0,
+  SERIALIZED_IN_INTERVAL_FLAG = 1 << 1,
+  SERIALIZED_BRACKET_TERM_HAS_CONTENT_FLAG = 1 << 2,
+  SERIALIZED_RANGE_PENDING_FLAG = 1 << 3,
 };
 
 static void reset_bracket_tracking(ScannerState *state) {
   state->regex_bracket_term_state = REGEX_BRACKET_TERM_NONE;
+  state->regex_bracket_term_has_content = false;
   state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
   state->regex_bracket_first_element = REGEX_BRACKET_PENDING_NONE;
   state->regex_bracket_last_element = REGEX_BRACKET_PENDING_NONE;
@@ -266,27 +257,21 @@ static void reset_bracket_tracking(ScannerState *state) {
   state->regex_bracket_range_pending = false;
 }
 
-static void set_regex_position(
-  ScannerState *state,
-  bool at_branch_start,
-  enum RegexDuplicationState duplication_state,
-  bool after_alternation,
-  bool after_anchor
-) {
-  state->regex_at_branch_start = at_branch_start;
-  state->regex_duplication_state = duplication_state;
-  state->regex_after_alternation = after_alternation;
-  state->regex_after_anchor = after_anchor;
+static bool regex_at_branch_start(const ScannerState *state) {
+  return state->regex_position ==
+    REGEX_AT_BRANCH_START ||
+#if SED_REGEX_EXTENDED
+    state->regex_position == REGEX_AFTER_ALTERNATION;
+#else
+    state->regex_position == REGEX_AFTER_ANCHOR;
+#endif
 }
 
 static void reset_mode_tracking(ScannerState *state) {
   state->regex_state = REGEX_OUTSIDE_BRACKET;
-  state->regex_at_branch_start = false;
-  state->regex_duplication_state = REGEX_DUPLICATION_NONE;
-  state->regex_after_alternation = false;
-  state->regex_after_anchor = false;
-  state->text_state = TEXT_EMPTY;
-  state->regex_interval_state = REGEX_INTERVAL_NONE;
+  state->regex_position = REGEX_AFTER_ATOM;
+  state->text_line_has_content = false;
+  state->regex_in_interval = false;
   reset_bracket_tracking(state);
   state->regex_group_depth = 0;
 }
@@ -305,14 +290,18 @@ static void sed_scanner_destroy(void *payload) {
   ts_free(payload);
 }
 
-static void serialize_uint16(char *buffer, unsigned offset, uint16_t value) {
-  buffer[offset] = (char)(value & UINT16_C(0xff));
-  buffer[offset + 1] = (char)((value >> 8) & UINT16_C(0xff));
+static void serialize_uint32(char *buffer, unsigned offset, uint32_t value) {
+  buffer[offset] = (char)(value & UINT32_C(0xff));
+  buffer[offset + 1] = (char)((value >> 8) & UINT32_C(0xff));
+  buffer[offset + 2] = (char)((value >> 16) & UINT32_C(0xff));
+  buffer[offset + 3] = (char)((value >> 24) & UINT32_C(0xff));
 }
 
-static uint16_t deserialize_uint16(const char *buffer, unsigned offset) {
-  return (uint16_t)((uint16_t)(unsigned char)buffer[offset] |
-    ((uint16_t)(unsigned char)buffer[offset + 1] << 8));
+static uint32_t deserialize_uint32(const char *buffer, unsigned offset) {
+  return (uint32_t)(unsigned char)buffer[offset] |
+    ((uint32_t)(unsigned char)buffer[offset + 1] << 8) |
+    ((uint32_t)(unsigned char)buffer[offset + 2] << 16) |
+    ((uint32_t)(unsigned char)buffer[offset + 3] << 24);
 }
 
 static bool is_regex_mode(enum ScannerMode mode) {
@@ -321,243 +310,84 @@ static bool is_regex_mode(enum ScannerMode mode) {
 
 static unsigned sed_scanner_serialize(void *payload, char *buffer) {
   const ScannerState *state = payload;
-  const uint32_t delimiter = (uint32_t)state->delimiter;
 
-  buffer[0] = SCANNER_SERIALIZATION_VERSION;
-  buffer[1] = (char)state->mode;
-  buffer[2] = (char)state->regex_state;
+  buffer[0] = (char)state->mode;
+  buffer[1] = (char)state->regex_state;
+  buffer[2] = (char)state->regex_position;
   buffer[3] =
-    (state->regex_at_branch_start ? SERIALIZED_AT_BRANCH_START_FLAG : 0) |
-    (state->regex_after_alternation ? SERIALIZED_AFTER_ALTERNATION_FLAG : 0) |
-    (state->regex_after_anchor ? SERIALIZED_AFTER_ANCHOR_FLAG : 0) |
-    ((unsigned char)state->text_state << SERIALIZED_TEXT_STATE_SHIFT);
-  buffer[4] = (char)(delimiter & UINT32_C(0xff));
-  buffer[5] = (char)((delimiter >> 8) & UINT32_C(0xff));
-  buffer[6] = (char)((delimiter >> 16) & UINT32_C(0xff));
-  buffer[7] = (char)((delimiter >> 24) & UINT32_C(0xff));
-  serialize_uint16(buffer, 8, state->regex_group_depth);
-  buffer[10] = (char)state->regex_interval_state;
-  buffer[11] = (char)state->regex_bracket_term_state;
-  buffer[12] = (char)state->regex_bracket_pending_element;
-  buffer[13] = (char)state->regex_bracket_first_element;
-  buffer[14] = (char)state->regex_bracket_last_element;
-  buffer[15] = (char)state->regex_bracket_element_count;
-  buffer[16] =
-    (state->regex_bracket_range_pending ? SERIALIZED_RANGE_PENDING_FLAG : 0) |
-    ((unsigned char)state->regex_duplication_state
-      << SERIALIZED_DUPLICATION_STATE_SHIFT);
+    (state->text_line_has_content ? SERIALIZED_TEXT_HAS_CONTENT_FLAG : 0) |
+    (state->regex_in_interval ? SERIALIZED_IN_INTERVAL_FLAG : 0) |
+    (state->regex_bracket_term_has_content
+        ? SERIALIZED_BRACKET_TERM_HAS_CONTENT_FLAG
+        : 0) |
+    (state->regex_bracket_range_pending ? SERIALIZED_RANGE_PENDING_FLAG : 0);
+  serialize_uint32(buffer, 4, (uint32_t)state->delimiter);
+  serialize_uint32(buffer, 8, state->regex_group_depth);
+  buffer[12] = (char)state->regex_bracket_term_state;
+  buffer[13] = (char)state->regex_bracket_pending_element;
+  buffer[14] = (char)state->regex_bracket_first_element;
+  buffer[15] = (char)state->regex_bracket_last_element;
+  buffer[16] = (char)state->regex_bracket_element_count;
   return SCANNER_SERIALIZED_STATE_SIZE;
 }
 
-static bool bracket_tracking_is_reset(const ScannerState *state) {
-  return state->regex_bracket_term_state ==
-    REGEX_BRACKET_TERM_NONE &&
-    state->regex_bracket_pending_element ==
-    REGEX_BRACKET_PENDING_NONE &&
-    state->regex_bracket_first_element ==
-    REGEX_BRACKET_PENDING_NONE &&
-    state->regex_bracket_last_element ==
-    REGEX_BRACKET_PENDING_NONE &&
-    state->regex_bracket_element_count ==
-    0 &&
-    !state->regex_bracket_range_pending;
-}
-
-static bool regex_position_is_reset(const ScannerState *state) {
-  return !state->regex_at_branch_start &&
-    state->regex_duplication_state ==
-    REGEX_DUPLICATION_NONE &&
-    !state->regex_after_alternation &&
-    !state->regex_after_anchor;
-}
-
-static bool deserialized_delimiter_is_valid(uint32_t delimiter) {
-  return delimiter !=
+static bool source_character_is_valid(int32_t character) {
+  const uint32_t code_point = (uint32_t)character;
+  return code_point !=
     0 &&
-    delimiter <=
+    code_point <=
     UINT32_C(0x10ffff) &&
-    !(delimiter >= UINT32_C(0xd800) && delimiter <= UINT32_C(0xdfff)) &&
-    delimiter !=
-    (uint32_t)'\\' &&
-    delimiter != (uint32_t)'\n';
+    !(code_point >= UINT32_C(0xd800) && code_point <= UINT32_C(0xdfff));
 }
 
-static bool deserialized_state_is_valid(const ScannerState *candidate) {
-  if (candidate->mode == MODE_NONE) {
-    return false;
-  }
-
-  if (candidate->mode == MODE_TEXT) {
-    return candidate->delimiter ==
-      0 &&
-      candidate->regex_state ==
-      REGEX_OUTSIDE_BRACKET &&
-      regex_position_is_reset(candidate) &&
-      candidate->regex_group_depth ==
-      0 &&
-      candidate->regex_interval_state ==
-      REGEX_INTERVAL_NONE &&
-      bracket_tracking_is_reset(candidate);
-  }
-
-  if (!deserialized_delimiter_is_valid((uint32_t)candidate->delimiter)) {
-    return false;
-  }
-
-  if (!is_regex_mode(candidate->mode)) {
-    return candidate->regex_state ==
-      REGEX_OUTSIDE_BRACKET &&
-      regex_position_is_reset(candidate) &&
-      candidate->text_state ==
-      TEXT_EMPTY &&
-      candidate->regex_interval_state ==
-      REGEX_INTERVAL_NONE &&
-      bracket_tracking_is_reset(candidate) &&
-      candidate->regex_group_depth == 0;
-  }
-
-  if (candidate->text_state != TEXT_EMPTY) {
-    return false;
-  }
-
-  if (candidate->regex_state == REGEX_OUTSIDE_BRACKET) {
-    return bracket_tracking_is_reset(candidate);
-  }
-
-  if (!regex_position_is_reset(candidate)) {
-    return false;
-  }
-
-  if (
-    candidate->regex_state ==
-    REGEX_BRACKET_FIRST ||
-    candidate->regex_state == REGEX_BRACKET_AFTER_CARET
-  ) {
-    return bracket_tracking_is_reset(candidate);
-  }
-
-  return true;
+static bool delimiter_character_is_valid(int32_t character) {
+  return source_character_is_valid(character) &&
+    character !=
+    '\\' &&
+    character != '\n';
 }
 
 static void
 sed_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
   ScannerState *state = payload;
-  reset_state(state);
-
-  if (
-    length !=
-    SCANNER_SERIALIZED_STATE_SIZE ||
-    (unsigned char)buffer[0] != SCANNER_SERIALIZATION_VERSION
-  ) {
+  if (length == 0) {
+    reset_state(state);
     return;
   }
 
-  const unsigned char mode_flags = (unsigned char)buffer[3];
-  const unsigned char regex_bracket_flags = (unsigned char)buffer[16];
-  const ScannerState candidate = {
-    .delimiter = (int32_t)((uint32_t)(unsigned char)buffer[4] |
-      ((uint32_t)(unsigned char)buffer[5] << 8) |
-      ((uint32_t)(unsigned char)buffer[6] << 16) |
-      ((uint32_t)(unsigned char)buffer[7] << 24)),
-    .mode = (enum ScannerMode)(unsigned char)buffer[1],
-    .regex_state = (enum RegexState)(unsigned char)buffer[2],
-    .regex_at_branch_start =
-      (mode_flags & SERIALIZED_AT_BRANCH_START_FLAG) != 0,
-    .regex_duplication_state = (enum RegexDuplicationState)(
-      (regex_bracket_flags >> SERIALIZED_DUPLICATION_STATE_SHIFT) & 3U
-    ),
-    .regex_after_alternation =
-      (mode_flags & SERIALIZED_AFTER_ALTERNATION_FLAG) != 0,
-    .regex_after_anchor = (mode_flags & SERIALIZED_AFTER_ANCHOR_FLAG) != 0,
-    .text_state =
-      (enum TextState)((mode_flags >> SERIALIZED_TEXT_STATE_SHIFT) & 3U),
-    .regex_interval_state = (enum RegexIntervalState)(unsigned char)buffer[10],
+  const unsigned char flags = (unsigned char)buffer[3];
+  *state = (ScannerState){
+    .mode = (enum ScannerMode)(unsigned char)buffer[0],
+    .regex_state = (enum RegexState)(unsigned char)buffer[1],
+    .regex_position = (enum RegexPosition)(unsigned char)buffer[2],
+    .text_line_has_content = (flags & SERIALIZED_TEXT_HAS_CONTENT_FLAG) != 0,
+    .regex_in_interval = (flags & SERIALIZED_IN_INTERVAL_FLAG) != 0,
+    .regex_bracket_term_has_content =
+      (flags & SERIALIZED_BRACKET_TERM_HAS_CONTENT_FLAG) != 0,
+    .regex_bracket_range_pending = (flags & SERIALIZED_RANGE_PENDING_FLAG) != 0,
+    .delimiter = (int32_t)deserialize_uint32(buffer, 4),
+    .regex_group_depth = deserialize_uint32(buffer, 8),
     .regex_bracket_term_state =
-      (enum RegexBracketTermState)(unsigned char)buffer[11],
+      (enum RegexBracketTermState)(unsigned char)buffer[12],
     .regex_bracket_pending_element =
-      (enum RegexBracketPendingElement)(unsigned char)buffer[12],
-    .regex_bracket_first_element =
       (enum RegexBracketPendingElement)(unsigned char)buffer[13],
-    .regex_bracket_last_element =
+    .regex_bracket_first_element =
       (enum RegexBracketPendingElement)(unsigned char)buffer[14],
-    .regex_bracket_element_count = (uint8_t)(unsigned char)buffer[15],
-    .regex_bracket_range_pending =
-      (regex_bracket_flags & SERIALIZED_RANGE_PENDING_FLAG) != 0,
-    .regex_group_depth = deserialize_uint16(buffer, 8),
+    .regex_bracket_last_element =
+      (enum RegexBracketPendingElement)(unsigned char)buffer[15],
+    .regex_bracket_element_count = (uint8_t)(unsigned char)buffer[16],
   };
-
-  if (candidate.mode > MODE_TEXT) {
-    return;
-  }
-
-  if (candidate.regex_state > REGEX_BRACKET_BODY) {
-    return;
-  }
-
-  if ((mode_flags & (unsigned char)~SERIALIZED_MODE_FLAGS_MAXIMUM) != 0) {
-    return;
-  }
-  if (candidate.text_state > TEXT_AFTER_ESCAPED_NEWLINE) {
-    return;
-  }
-#if !SED_REGEX_EXTENDED
-  if (candidate.regex_after_alternation) {
-    return;
-  }
-#endif
-
-  if (candidate.regex_interval_state > REGEX_INTERVAL_AFTER_MAXIMUM) {
-    return;
-  }
-  if (candidate.regex_bracket_term_state > REGEX_BRACKET_TERM_EQUAL) {
-    return;
-  }
-  if (
-    candidate.regex_bracket_pending_element >
-    REGEX_BRACKET_PENDING_COLON ||
-    candidate.regex_bracket_first_element >
-    REGEX_BRACKET_PENDING_COLON ||
-    candidate.regex_bracket_last_element >
-    REGEX_BRACKET_PENDING_COLON ||
-    candidate.regex_bracket_element_count >
-    3U ||
-    (regex_bracket_flags & (unsigned char)~SERIALIZED_BRACKET_FLAGS_MAXIMUM) !=
-    0 ||
-#if SED_REGEX_EXTENDED
-    candidate.regex_duplication_state > REGEX_AFTER_REPETITION_MODIFIER
-#else
-    candidate.regex_duplication_state > REGEX_AFTER_DUPLICATION_SYMBOL
-#endif
-  ) {
-    return;
-  }
-  if (
-    (candidate.regex_bracket_element_count ==
-      0 &&
-      (candidate.regex_bracket_first_element !=
-        REGEX_BRACKET_PENDING_NONE ||
-        candidate.regex_bracket_last_element != REGEX_BRACKET_PENDING_NONE)) ||
-    (candidate.regex_bracket_element_count >
-      0 &&
-      (candidate.regex_bracket_first_element ==
-        REGEX_BRACKET_PENDING_NONE ||
-        candidate.regex_bracket_last_element == REGEX_BRACKET_PENDING_NONE)) ||
-    (candidate.regex_bracket_pending_element !=
-      REGEX_BRACKET_PENDING_NONE &&
-      candidate.regex_bracket_range_pending)
-  ) {
-    return;
-  }
-
-  if (deserialized_state_is_valid(&candidate)) {
-    *state = candidate;
-  }
 }
 
 static void advance(TSLexer *lexer) {
   lexer->advance(lexer, false);
 }
 
+static void consume(TSLexer *lexer) {
+  advance(lexer);
+  lexer->mark_end(lexer);
+}
+
 static bool is_blank(int32_t character) {
   return character == ' ' || character == '\t';
 }
@@ -566,14 +396,13 @@ static bool is_digit(int32_t character) {
   return character >= '0' && character <= '9';
 }
 
-static void advance_past_blanks(TSLexer *lexer) {
-  while (is_blank(lexer->lookahead)) {
-    advance(lexer);
-  }
+static bool is_letter(int32_t character) {
+  return (character >= 'a' && character <= 'z') ||
+    (character >= 'A' && character <= 'Z');
 }
 
-static void advance_past_escaped_character(TSLexer *lexer) {
-  if (!lexer->eof(lexer) && lexer->lookahead != '\n') {
+static void advance_past_blanks(TSLexer *lexer) {
+  while (is_blank(lexer->lookahead)) {
     advance(lexer);
   }
 }
@@ -585,12 +414,7 @@ static void skip_blanks(TSLexer *lexer) {
 }
 
 static bool invalid_delimiter(TSLexer *lexer) {
-  return lexer->eof(lexer) ||
-    lexer->lookahead ==
-    0 ||
-    lexer->lookahead ==
-    '\\' ||
-    lexer->lookahead == '\n';
+  return lexer->eof(lexer) || !delimiter_character_is_valid(lexer->lookahead);
 }
 
 static bool delimiter_is_missing(TSLexer *lexer) {
@@ -609,32 +433,42 @@ static bool scan_simple_delimiter(
   state->delimiter = lexer->lookahead;
   state->mode = next_mode;
   reset_mode_tracking(state);
-  state->regex_at_branch_start =
-    next_mode == MODE_REGEX_ADDRESS || next_mode == MODE_SUBSTITUTE_PATTERN;
-  advance(lexer);
-  lexer->mark_end(lexer);
+  state->regex_position =
+    is_regex_mode(next_mode) ? REGEX_AT_BRANCH_START : REGEX_AFTER_ATOM;
+  consume(lexer);
   return true;
 }
 
-static bool scan_mode_delimiter(
-  TSLexer *lexer,
-  ScannerState *state,
-  enum ScannerMode next_mode
-) {
-  if (lexer->lookahead != state->delimiter) {
+static bool
+emit_symbol(const bool *valid_symbols, TSSymbol candidate, TSSymbol *symbol) {
+  if (!valid_symbols[candidate]) {
     return false;
   }
 
-  state->mode = next_mode;
-  reset_mode_tracking(state);
-  if (next_mode == MODE_NONE) {
-    state->delimiter = 0;
-  }
-  advance(lexer);
-  lexer->mark_end(lexer);
+  *symbol = candidate;
   return true;
 }
 
+static bool consume_as(
+  TSLexer *lexer,
+  const bool *valid_symbols,
+  TSSymbol candidate,
+  TSSymbol *symbol
+) {
+  consume(lexer);
+  return emit_symbol(valid_symbols, candidate, symbol);
+}
+
+static bool end_mode(
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol candidate,
+  TSSymbol *symbol
+) {
+  reset_state(state);
+  return emit_symbol(valid_symbols, candidate, symbol);
+}
+
 static bool scan_active_mode_delimiter(
   TSLexer *lexer,
   ScannerState *state,
@@ -670,26 +504,15 @@ static bool scan_active_mode_delimiter(
     return false;
   }
 
-  if (
-    !valid_symbols[candidate] || !scan_mode_delimiter(lexer, state, next_mode)
-  ) {
-    return false;
+  state->mode = next_mode;
+  reset_mode_tracking(state);
+  if (next_mode == MODE_NONE) {
+    state->delimiter = 0;
   }
-
-  *symbol = candidate;
-  return true;
-}
-
-static void consume(TSLexer *lexer) {
-  advance(lexer);
-  lexer->mark_end(lexer);
+  return consume_as(lexer, valid_symbols, candidate, symbol);
 }
 
 static bool scan_text_command_start(TSLexer *lexer, ScannerState *state) {
-  if (state->mode != MODE_NONE || lexer->lookahead != '\\') {
-    return false;
-  }
-
   lexer->mark_end(lexer);
   advance(lexer);
 
@@ -702,47 +525,25 @@ static bool scan_text_command_start(TSLexer *lexer, ScannerState *state) {
   return true;
 }
 
-static bool scan_to_physical_line_end(TSLexer *lexer, bool consumed) {
-  while (!lexer->eof(lexer)) {
-    if (lexer->lookahead == '\n') {
-      return consumed;
-    }
-
+static bool scan_line_rest(TSLexer *lexer, bool ends_at_semicolon) {
+  bool consumed = false;
+  while (
+    !lexer->eof(lexer) &&
+    lexer->lookahead !=
+    0 &&
+    lexer->lookahead !=
+    '\n' &&
+    !(ends_at_semicolon && lexer->lookahead == ';')
+  ) {
     consume(lexer);
     consumed = true;
   }
-
   return consumed;
 }
 
-static bool scan_file_argument(TSLexer *lexer) {
-  if (
-    lexer->eof(lexer) || is_blank(lexer->lookahead) || lexer->lookahead == '\n'
-  ) {
-    return false;
-  }
-
-  consume(lexer);
-  return scan_to_physical_line_end(lexer, true);
-}
-
-static bool scan_substitution_wfile_argument(TSLexer *lexer) {
-  if (
-    lexer->eof(lexer) ||
-    is_blank(lexer->lookahead) ||
-    lexer->lookahead ==
-    '\n' ||
-    lexer->lookahead == ';'
-  ) {
-    return false;
-  }
-
-  do {
-    consume(lexer);
-  } while (
-    !lexer->eof(lexer) && lexer->lookahead != '\n' && lexer->lookahead != ';'
-  );
-  return true;
+static bool scan_file_argument(TSLexer *lexer, bool ends_at_semicolon) {
+  return !is_blank(lexer->lookahead) &&
+    scan_line_rest(lexer, ends_at_semicolon);
 }
 
 enum FlagAfterWriteScan {
@@ -781,55 +582,14 @@ static enum FlagAfterWriteScan scan_flag_after_write_marker(TSLexer *lexer) {
                                     : FLAG_AFTER_WRITE_FALLBACK;
 }
 
-static bool scan_right_brace(TSLexer *lexer, ScannerState *state) {
-  if (state->mode != MODE_NONE) {
-    return false;
-  }
-
-  skip_blanks(lexer);
-
-  if (lexer->lookahead != '}') {
-    return false;
-  }
-
-  consume(lexer);
-  return true;
-}
-
-static bool scan_reserved_unknown_function(TSLexer *lexer) {
-  const int32_t character = lexer->lookahead;
-  if (
-    !is_digit(character) &&
-    character !=
-    '$' &&
-    character !=
-    '/' &&
-    character != '\\'
-  ) {
-    return false;
-  }
-
-  consume(lexer);
-  return true;
-}
-
 enum LiteralScanResult {
   LITERAL_SCAN_NONE,
   LITERAL_SCAN_TOKEN,
+  LITERAL_SCAN_INVALID_CHARACTER,
   LITERAL_SCAN_LINE_END,
 };
 
-static bool
-emit_symbol(const bool *valid_symbols, TSSymbol candidate, TSSymbol *symbol) {
-  if (!valid_symbols[candidate]) {
-    return false;
-  }
-
-  *symbol = candidate;
-  return true;
-}
-
-static bool emit_missing_marker(
+static bool emit_marker(
   TSLexer *lexer,
   const bool *valid_symbols,
   TSSymbol candidate,
@@ -840,10 +600,23 @@ static bool emit_missing_marker(
   }
 
   lexer->mark_end(lexer);
+  // Keep the marker empty while recording its full lookahead character.
+  if (!lexer->eof(lexer)) {
+    advance(lexer);
+  }
   *symbol = candidate;
   return true;
 }
 
+static bool can_start_address(TSLexer *lexer) {
+  return is_digit(lexer->lookahead) ||
+    lexer->lookahead ==
+    '$' ||
+    lexer->lookahead ==
+    '/' ||
+    lexer->lookahead == '\\';
+}
+
 static bool at_command_boundary(TSLexer *lexer) {
   return lexer->eof(lexer) ||
     lexer->lookahead ==
@@ -853,13 +626,23 @@ static bool at_command_boundary(TSLexer *lexer) {
     lexer->lookahead == '}';
 }
 
-static bool can_start_address(TSLexer *lexer) {
-  return is_digit(lexer->lookahead) ||
-    lexer->lookahead ==
-    '$' ||
-    lexer->lookahead ==
-    '/' ||
-    lexer->lookahead == '\\';
+static TSSymbol missing_command_separator_marker(
+  const TSLexer *lexer,
+  const bool *valid_symbols
+) {
+  if (lexer->lookahead == '}') {
+    if (valid_symbols[MISSING_SEPARATOR_BEFORE_UNMATCHED_BRACE_MARKER]) {
+      return MISSING_SEPARATOR_BEFORE_UNMATCHED_BRACE_MARKER;
+    }
+    if (valid_symbols[MISSING_COMMAND_SEPARATOR_MARKER]) {
+      return MISSING_COMMAND_SEPARATOR_MARKER;
+    }
+  } else if (
+    lexer->eof(lexer) && valid_symbols[INCOMPLETE_COMMAND_SEPARATOR_MARKER]
+  ) {
+    return INCOMPLETE_COMMAND_SEPARATOR_MARKER;
+  }
+  return ERROR_SENTINEL;
 }
 
 enum PostBlankRecoveryScan {
@@ -913,22 +696,10 @@ static enum PostBlankRecoveryScan scan_post_blank_recovery(
     *symbol = MISSING_ADDRESS_SEPARATOR_MARKER;
     return POST_BLANK_RECOVERY_TOKEN;
   }
-  if (lexer->lookahead == '}') {
-    if (valid_symbols[MISSING_SEPARATOR_BEFORE_UNMATCHED_BRACE_MARKER]) {
-      *symbol = MISSING_SEPARATOR_BEFORE_UNMATCHED_BRACE_MARKER;
-      return POST_BLANK_RECOVERY_TOKEN;
-    }
-    if (valid_symbols[MISSING_COMMAND_SEPARATOR_MARKER]) {
-      *symbol = MISSING_COMMAND_SEPARATOR_MARKER;
-      return POST_BLANK_RECOVERY_TOKEN;
-    }
-    return POST_BLANK_RECOVERY_FAILED;
-  }
-  if (lexer->eof(lexer) && valid_symbols[INCOMPLETE_COMMAND_SEPARATOR_MARKER]) {
-    *symbol = INCOMPLETE_COMMAND_SEPARATOR_MARKER;
-    return POST_BLANK_RECOVERY_TOKEN;
-  }
-  return POST_BLANK_RECOVERY_FAILED;
+  // The blanks precede the marker as padding of the brace or the source end.
+  *symbol = missing_command_separator_marker(lexer, valid_symbols);
+  return *symbol == ERROR_SENTINEL ? POST_BLANK_RECOVERY_FAILED
+                                   : POST_BLANK_RECOVERY_TOKEN;
 }
 
 static bool scan_text_token(
@@ -938,80 +709,66 @@ static bool scan_text_token(
   TSSymbol *symbol
 ) {
   if (lexer->eof(lexer)) {
-    if (state->text_state == TEXT_AFTER_ESCAPED_NEWLINE) {
-      if (!emit_missing_marker(
-            lexer,
-            valid_symbols,
-            MISSING_TEXT_MARKER,
-            symbol
-          )) {
-        return false;
-      }
-      state->text_state = TEXT_HAS_CONTENT;
-      return true;
-    }
     if (
-      state->text_state ==
-      TEXT_EMPTY &&
-      emit_missing_marker(lexer, valid_symbols, MISSING_TEXT_MARKER, symbol)
+      !state->text_line_has_content &&
+      emit_marker(lexer, valid_symbols, MISSING_TEXT_MARKER, symbol)
     ) {
-      state->text_state = TEXT_HAS_CONTENT;
+      state->text_line_has_content = true;
       return true;
     }
-    if (!valid_symbols[TEXT_EOF]) {
-      return false;
-    }
     lexer->mark_end(lexer);
-    reset_state(state);
-    *symbol = TEXT_EOF;
-    return true;
+    return end_mode(state, valid_symbols, TEXT_EOF, symbol);
   }
 
   if (lexer->lookahead == '\n') {
-    if (!valid_symbols[TEXT_LINE_END]) {
-      return false;
-    }
     lexer->mark_end(lexer);
-    reset_state(state);
-    *symbol = TEXT_LINE_END;
-    return true;
+    return end_mode(state, valid_symbols, TEXT_LINE_END, symbol);
+  }
+
+  if (lexer->lookahead == 0) {
+    state->text_line_has_content = true;
+    return consume_as(lexer, valid_symbols, NUL_CHARACTER, symbol);
   }
 
   if (lexer->lookahead == '\\') {
-    advance(lexer);
-    lexer->mark_end(lexer);
+    consume(lexer);
 
     if (lexer->eof(lexer)) {
-      state->text_state = TEXT_HAS_CONTENT;
+      state->text_line_has_content = true;
       return emit_symbol(valid_symbols, TEXT_UNSPECIFIED_ESCAPE, symbol);
     }
+    if (lexer->lookahead == 0) {
+      state->text_line_has_content = true;
+      return emit_symbol(valid_symbols, ESCAPE_PREFIX, symbol);
+    }
     if (lexer->lookahead == '\\') {
       consume(lexer);
-      state->text_state = TEXT_HAS_CONTENT;
+      state->text_line_has_content = true;
       return emit_symbol(valid_symbols, TEXT_BACKSLASH_ESCAPE, symbol);
     }
     if (lexer->lookahead == '\n') {
       consume(lexer);
-      state->text_state = TEXT_AFTER_ESCAPED_NEWLINE;
+      state->text_line_has_content = false;
       return emit_symbol(valid_symbols, TEXT_ESCAPED_NEWLINE, symbol);
     }
 
     consume(lexer);
-    state->text_state = TEXT_HAS_CONTENT;
+    state->text_line_has_content = true;
     return emit_symbol(valid_symbols, TEXT_UNSPECIFIED_ESCAPE, symbol);
   }
 
-  if (!valid_symbols[TEXT_LITERAL]) {
-    return false;
-  }
   do {
     consume(lexer);
   } while (
-    !lexer->eof(lexer) && lexer->lookahead != '\\' && lexer->lookahead != '\n'
+    !lexer->eof(lexer) &&
+    lexer->lookahead !=
+    0 &&
+    lexer->lookahead !=
+    '\\' &&
+    lexer->lookahead != '\n'
   );
-  state->text_state = TEXT_HAS_CONTENT;
-  *symbol = TEXT_LITERAL;
-  return true;
+  state->text_line_has_content = true;
+  return emit_symbol(valid_symbols, TEXT_LITERAL, symbol);
 }
 
 static bool regex_is_inside_bracket(const ScannerState *state) {
@@ -1068,12 +825,14 @@ begin_single_bracket_element(ScannerState *state, int32_t character) {
 }
 
 static void begin_compound_bracket_element(ScannerState *state) {
+  state->regex_bracket_term_has_content = false;
   if (!state->regex_bracket_range_pending) {
     commit_pending_bracket_element(state);
   }
 }
 
 static void finish_compound_bracket_element(ScannerState *state) {
+  state->regex_bracket_term_has_content = false;
   if (state->regex_bracket_range_pending) {
     record_bracket_element(state, REGEX_BRACKET_PENDING_OTHER);
     state->regex_bracket_range_pending = false;
@@ -1101,16 +860,6 @@ static void finish_first_bracket_element(ScannerState *state) {
   }
 }
 
-static void
-update_bracket_state_after_literal(ScannerState *state, int32_t character) {
-  if (state->regex_state == REGEX_BRACKET_FIRST) {
-    state->regex_state =
-      character == '^' ? REGEX_BRACKET_AFTER_CARET : REGEX_BRACKET_BODY;
-  } else if (state->regex_state == REGEX_BRACKET_AFTER_CARET) {
-    state->regex_state = REGEX_BRACKET_BODY;
-  }
-}
-
 static bool
 regex_literal_boundary(const ScannerState *state, int32_t character) {
   if (state->regex_state == REGEX_OUTSIDE_BRACKET) {
@@ -1162,33 +911,58 @@ scan_regex_literal(TSLexer *lexer, ScannerState *state) {
   consume(lexer);
   if (regex_is_inside_bracket(state)) {
     begin_single_bracket_element(state, character);
+    finish_first_bracket_element(state);
   }
-  update_bracket_state_after_literal(state, character);
-  return LITERAL_SCAN_TOKEN;
+  return source_character_is_valid(character) ? LITERAL_SCAN_TOKEN
+                                              : LITERAL_SCAN_INVALID_CHARACTER;
 }
 
 static TSSymbol
-regex_unterminated_symbol(enum ScannerMode mode, bool at_end_of_source) {
-  if (mode == MODE_REGEX_ADDRESS) {
+unterminated_mode_symbol(enum ScannerMode mode, bool at_end_of_source) {
+  switch (mode) {
+  case MODE_REGEX_ADDRESS:
     return at_end_of_source ? REGEX_UNTERMINATED_ADDRESS
                             : REGEX_LINE_UNTERMINATED_ADDRESS;
+  case MODE_SUBSTITUTE_PATTERN:
+    return at_end_of_source ? REGEX_UNTERMINATED_SUBSTITUTE
+                            : REGEX_LINE_UNTERMINATED_SUBSTITUTE;
+  case MODE_SUBSTITUTE_REPLACEMENT:
+    return at_end_of_source ? REPLACEMENT_UNTERMINATED
+                            : REPLACEMENT_LINE_UNTERMINATED;
+  case MODE_TRANSLATE_SOURCE:
+    return at_end_of_source ? TRANSLATE_UNTERMINATED_SOURCE
+                            : TRANSLATE_LINE_UNTERMINATED_SOURCE;
+  case MODE_TRANSLATE_DESTINATION:
+    return at_end_of_source ? TRANSLATE_UNTERMINATED_DESTINATION
+                            : TRANSLATE_LINE_UNTERMINATED_DESTINATION;
+  case MODE_NONE:
+  case MODE_TEXT:
+    break;
   }
-  return at_end_of_source ? REGEX_UNTERMINATED_SUBSTITUTE
-                          : REGEX_LINE_UNTERMINATED_SUBSTITUTE;
+  return ERROR_SENTINEL;
 }
 
-static bool emit_unterminated(
-  ScannerState *state,
-  const bool *valid_symbols,
-  TSSymbol candidate,
-  TSSymbol *symbol
-) {
-  if (!emit_symbol(valid_symbols, candidate, symbol)) {
-    return false;
-  }
+static const struct {
+  int32_t marker;
+  TSSymbol open_symbol;
+  TSSymbol close_symbol;
+} bracket_terms[] = {
+  [REGEX_BRACKET_TERM_COLON] = {':', REGEX_OPEN_COLON, REGEX_COLON_CLOSE},
+  [REGEX_BRACKET_TERM_DOT] = {'.', REGEX_OPEN_DOT, REGEX_DOT_CLOSE},
+  [REGEX_BRACKET_TERM_EQUAL] = {'=', REGEX_OPEN_EQUAL, REGEX_EQUAL_CLOSE},
+};
 
-  reset_state(state);
-  return true;
+static enum RegexBracketTermState bracket_term_for_marker(int32_t character) {
+  for (
+    enum RegexBracketTermState term_state = REGEX_BRACKET_TERM_COLON;
+    term_state <= REGEX_BRACKET_TERM_EQUAL;
+    term_state++
+  ) {
+    if (bracket_terms[term_state].marker == character) {
+      return term_state;
+    }
+  }
+  return REGEX_BRACKET_TERM_NONE;
 }
 
 static bool scan_regex_bracket_opener(
@@ -1210,35 +984,22 @@ static bool scan_regex_bracket_opener(
 
   lexer->mark_end(lexer);
 
-  TSSymbol candidate;
-  enum RegexBracketTermState term_state;
-  switch (lexer->lookahead) {
-  case ':':
-    candidate = REGEX_OPEN_COLON;
-    term_state = REGEX_BRACKET_TERM_COLON;
-    break;
-  case '.':
-    candidate = REGEX_OPEN_DOT;
-    term_state = REGEX_BRACKET_TERM_DOT;
-    break;
-  case '=':
-    candidate = REGEX_OPEN_EQUAL;
-    term_state = REGEX_BRACKET_TERM_EQUAL;
-    break;
-  default:
+  const enum RegexBracketTermState term_state =
+    bracket_term_for_marker(lexer->lookahead);
+  if (term_state == REGEX_BRACKET_TERM_NONE) {
     begin_single_bracket_element(state, '[');
     finish_first_bracket_element(state);
     return emit_symbol(valid_symbols, REGEX_BRACKET_LITERAL, symbol);
   }
 
-  if (!valid_symbols[candidate]) {
-    return false;
-  }
   begin_compound_bracket_element(state);
   finish_first_bracket_element(state);
   state->regex_bracket_term_state = term_state;
-  *symbol = candidate;
-  return true;
+  return emit_symbol(
+    valid_symbols,
+    bracket_terms[term_state].open_symbol,
+    symbol
+  );
 }
 
 static void record_bracket_term_character(
@@ -1255,19 +1016,7 @@ static void record_bracket_term_character(
 }
 
 static bool bracket_meta_character(int32_t character) {
-  return character == '^' || character == '-' || character == ']';
-}
-
-static int32_t
-bracket_term_close_marker(enum RegexBracketTermState term_state) {
-  switch (term_state) {
-  case REGEX_BRACKET_TERM_COLON:
-    return ':';
-  case REGEX_BRACKET_TERM_DOT:
-    return '.';
-  default:
-    return '=';
-  }
+  return character == '-' || character == ']';
 }
 
 static TSSymbol regex_bracket_term_content_symbol(
@@ -1281,61 +1030,46 @@ static TSSymbol regex_bracket_term_content_symbol(
   if (character_count > 1U) {
     return REGEX_COLL_ELEM_MULTI;
   }
-  if (
-    state->regex_bracket_term_state ==
-    REGEX_BRACKET_TERM_DOT &&
-    bracket_meta_character(single_character)
-  ) {
-    return REGEX_META_CHAR;
+  if (!bracket_meta_character(single_character)) {
+    return REGEX_COLL_ELEM_SINGLE;
   }
-  return REGEX_COLL_ELEM_SINGLE;
+  return state->regex_bracket_term_state == REGEX_BRACKET_TERM_DOT
+    ? REGEX_META_CHAR
+    : REGEX_MALFORMED_BRACKET_TERM;
 }
 
 static bool scan_regex_bracket_term_content(
   TSLexer *lexer,
   ScannerState *state,
-  int32_t close_marker,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
+  const int32_t close_marker =
+    bracket_terms[state->regex_bracket_term_state].marker;
   uint8_t character_count = 0;
   int32_t single_character = 0;
   bool stopped_at_close = false;
+  bool valid_class_name = true;
+  bool leading_bracket_is_content = !state->regex_bracket_term_has_content &&
+    state->regex_bracket_term_state != REGEX_BRACKET_TERM_COLON;
   lexer->mark_end(lexer);
 
-  if (
-    lexer->lookahead ==
-    ']' &&
-    state->regex_bracket_term_state != REGEX_BRACKET_TERM_COLON
-  ) {
-    advance(lexer);
-    lexer->mark_end(lexer);
-    record_bracket_term_character(&character_count, &single_character, ']');
-    if (lexer->lookahead == close_marker) {
-      advance(lexer);
-      if (lexer->lookahead == ']') {
-        const TSSymbol candidate = regex_bracket_term_content_symbol(
-          state,
-          character_count,
-          single_character
-        );
-        return emit_symbol(valid_symbols, candidate, symbol);
-      }
-      lexer->mark_end(lexer);
-      record_bracket_term_character(
-        &character_count,
-        &single_character,
-        close_marker
-      );
-    }
+  if (!lexer->eof(lexer) && !source_character_is_valid(lexer->lookahead)) {
+    state->regex_bracket_term_has_content = true;
+    return consume_as(lexer, valid_symbols, INVALID_CHARACTER, symbol);
   }
 
   for (;;) {
     if (
-      lexer->eof(lexer) || lexer->lookahead == '\n' || lexer->lookahead == ']'
+      lexer->eof(lexer) ||
+      lexer->lookahead ==
+      '\n' ||
+      !source_character_is_valid(lexer->lookahead) ||
+      (lexer->lookahead == ']' && !leading_bracket_is_content)
     ) {
       break;
     }
+    leading_bracket_is_content = false;
 
     if (lexer->lookahead == close_marker) {
       advance(lexer);
@@ -1344,6 +1078,7 @@ static bool scan_regex_bracket_term_content(
         break;
       }
       lexer->mark_end(lexer);
+      valid_class_name = false;
       record_bracket_term_character(
         &character_count,
         &single_character,
@@ -1353,6 +1088,10 @@ static bool scan_regex_bracket_term_content(
     }
 
     const int32_t character = lexer->lookahead;
+    valid_class_name = valid_class_name &&
+      (is_letter(character) ||
+        (is_digit(character) &&
+          (state->regex_bracket_term_has_content || character_count > 0)));
     consume(lexer);
     record_bracket_term_character(
       &character_count,
@@ -1362,169 +1101,155 @@ static bool scan_regex_bracket_term_content(
   }
 
   if (character_count == 0) {
+    const TSSymbol closing =
+      bracket_terms[state->regex_bracket_term_state].close_symbol;
+    if (stopped_at_close && valid_symbols[closing]) {
+      lexer->mark_end(lexer);
+      state->regex_bracket_term_state = REGEX_BRACKET_TERM_NONE;
+      finish_compound_bracket_element(state);
+      return emit_symbol(valid_symbols, closing, symbol);
+    }
     if (!stopped_at_close) {
       state->regex_bracket_term_state = REGEX_BRACKET_TERM_NONE;
       finish_compound_bracket_element(state);
     }
     return emit_symbol(valid_symbols, REGEX_MALFORMED_BRACKET_TERM, symbol);
   }
-  const TSSymbol candidate =
-    regex_bracket_term_content_symbol(state, character_count, single_character);
+  state->regex_bracket_term_has_content = true;
+  const TSSymbol candidate = state->regex_bracket_term_state ==
+      REGEX_BRACKET_TERM_COLON &&
+      !valid_class_name
+    ? REGEX_INVALID_CLASS_NAME
+    : regex_bracket_term_content_symbol(
+        state,
+        character_count,
+        single_character
+      );
   return emit_symbol(valid_symbols, candidate, symbol);
 }
 
 static bool scan_regex_bracket_term_close(
   TSLexer *lexer,
   ScannerState *state,
-  int32_t marker,
-  TSSymbol candidate,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  if (lexer->lookahead != marker) {
-    return false;
-  }
-
   consume(lexer);
   if (lexer->lookahead != ']') {
     return false;
   }
+  const TSSymbol candidate =
+    bracket_terms[state->regex_bracket_term_state].close_symbol;
   state->regex_bracket_term_state = REGEX_BRACKET_TERM_NONE;
   finish_compound_bracket_element(state);
   return emit_symbol(valid_symbols, candidate, symbol);
 }
 
-enum RegexIntervalPartResult {
-  REGEX_INTERVAL_PART_END,
-  REGEX_INTERVAL_PART_ESCAPED_CLOSE,
-  REGEX_INTERVAL_PART_INVALID,
-};
-
-static enum RegexIntervalPartResult scan_regex_interval_digits(
+static bool scan_regex_interval_open(
   TSLexer *lexer,
-  const ScannerState *state,
-  bool escaped_close,
-  bool *has_digits
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
 ) {
-  for (;;) {
-    if (is_digit(lexer->lookahead) && lexer->lookahead != state->delimiter) {
-      advance(lexer);
-      if (has_digits != NULL) {
-        *has_digits = true;
-      }
-      continue;
-    }
+  consume(lexer);
+  state->regex_in_interval = true;
+  return emit_symbol(valid_symbols, REGEX_INTERVAL_OPEN, symbol);
+}
 
-    if (escaped_close && lexer->lookahead == '\\') {
-      advance(lexer);
-      if (lexer->lookahead == '}' && state->delimiter != '}') {
-        return REGEX_INTERVAL_PART_ESCAPED_CLOSE;
-      }
-      advance_past_escaped_character(lexer);
-      return REGEX_INTERVAL_PART_INVALID;
-    }
+static bool end_interval(
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol candidate,
+  TSSymbol *symbol
+) {
+  state->regex_in_interval = false;
+  return emit_symbol(valid_symbols, candidate, symbol);
+}
 
-    return REGEX_INTERVAL_PART_END;
-  }
+static bool scan_regex_interval_close(
+  TSLexer *lexer,
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  consume(lexer);
+  return end_interval(state, valid_symbols, REGEX_INTERVAL_CLOSE, symbol);
 }
 
+#if !SED_REGEX_EXTENDED
 static bool
-scan_regex_interval_separator(TSLexer *lexer, const ScannerState *state) {
-  if (lexer->lookahead != ',' || state->delimiter == ',') {
-    return false;
-  }
-
-  advance(lexer);
-  return true;
+interval_escape_ends_content(const ScannerState *state, int32_t escaped) {
+  return (escaped == '}' || escaped == '(' || escaped == ')') &&
+    escaped != state->delimiter;
 }
+#endif
 
-static bool scan_regex_interval_tail(
-  TSLexer *lexer,
-  const ScannerState *state,
-  bool escaped_close
-) {
-  bool has_minimum = false;
-  enum RegexIntervalPartResult result =
-    scan_regex_interval_digits(lexer, state, escaped_close, &has_minimum);
-  if (result == REGEX_INTERVAL_PART_INVALID) {
-    return false;
-  }
-  if (result == REGEX_INTERVAL_PART_ESCAPED_CLOSE) {
+static void finish_malformed_escape(TSLexer *lexer) {
+  if (
+    !lexer->eof(lexer) &&
+    lexer->lookahead !=
+    '\n' &&
+    source_character_is_valid(lexer->lookahead)
+  ) {
     advance(lexer);
-    return has_minimum;
-  }
-
-  const bool has_separator = scan_regex_interval_separator(lexer, state);
-  if (!has_minimum) {
-    return false;
   }
+  lexer->mark_end(lexer);
+}
 
-  if (has_separator) {
-    result = scan_regex_interval_digits(lexer, state, escaped_close, NULL);
-    if (result == REGEX_INTERVAL_PART_INVALID) {
-      return false;
+static void
+scan_malformed_interval_content(TSLexer *lexer, const ScannerState *state) {
+  for (;;) {
+    const int32_t character = lexer->lookahead;
+    if (
+      lexer->eof(lexer) ||
+      !source_character_is_valid(character) ||
+      character ==
+      '\n' ||
+      character ==
+      state->delimiter ||
+      character == '['
+    ) {
+      return;
     }
-    if (result == REGEX_INTERVAL_PART_ESCAPED_CLOSE) {
-      advance(lexer);
-      return true;
+#if SED_REGEX_EXTENDED
+    if (
+      character ==
+      '}' ||
+      character ==
+      '(' ||
+      character ==
+      ')' ||
+      character == '|'
+    ) {
+      return;
     }
-  }
-
-  if (escaped_close) {
-    if (lexer->lookahead != '\\') {
-      return false;
+#endif
+    if (character != '\\') {
+      consume(lexer);
+      continue;
     }
+
     advance(lexer);
-    if (lexer->lookahead != '}' || state->delimiter == '}') {
-      advance_past_escaped_character(lexer);
-      return false;
+#if !SED_REGEX_EXTENDED
+    if (interval_escape_ends_content(state, lexer->lookahead)) {
+      return;
     }
+#endif
+    finish_malformed_escape(lexer);
   }
-
-  if (lexer->lookahead != '}' || state->delimiter == '}') {
-    return false;
-  }
-
-  advance(lexer);
-  return true;
 }
 
-static bool scan_regex_interval(
+static bool emit_malformed_interval(
   TSLexer *lexer,
   ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  advance(lexer);
-  lexer->mark_end(lexer);
-  state->regex_interval_state = REGEX_INTERVAL_EXPECT_MINIMUM;
-  return emit_symbol(valid_symbols, REGEX_INTERVAL_OPEN, symbol);
-}
-
-static bool emit_interval_issue(
-  TSLexer *lexer,
-  ScannerState *state,
-  TSSymbol candidate,
-  TSSymbol *symbol
-) {
-  lexer->mark_end(lexer);
-  state->regex_interval_state = REGEX_INTERVAL_NONE;
-  *symbol = candidate;
-  return true;
+  state->regex_in_interval =
+    !lexer->eof(lexer) && !source_character_is_valid(lexer->lookahead);
+  return emit_symbol(valid_symbols, REGEX_INVALID_INTERVAL, symbol);
 }
 
-static bool
-scan_invalid_interval_remainder(TSLexer *lexer, ScannerState *state);
-
-#if !SED_REGEX_EXTENDED
-static bool scan_regex_after_backslash(
-  TSLexer *lexer,
-  ScannerState *state,
-  const bool *valid_symbols,
-  TSSymbol *symbol
-);
-#endif
-
 static bool raw_duplication_symbol_follows(
   const TSLexer *lexer,
   const ScannerState *state
@@ -1537,88 +1262,38 @@ static bool raw_duplication_symbol_follows(
     '+' ||
     lexer->lookahead == '?';
 #else
-  return lexer->lookahead == '*' && !state->regex_at_branch_start;
+  return lexer->lookahead == '*' && !regex_at_branch_start(state);
 #endif
 }
 
-enum DuplicationContextScan {
-  DUPLICATION_CONTEXT_SKIPPED,
-  DUPLICATION_CONTEXT_TOKEN,
-  DUPLICATION_CONTEXT_CONSUMED,
-};
-
-static enum DuplicationContextScan scan_regex_duplication_context_marker(
-  TSLexer *lexer,
-  ScannerState *state,
-  const bool *valid_symbols,
-  TSSymbol *symbol
+static TSSymbol regex_duplication_context_marker(
+  const TSLexer *lexer,
+  const ScannerState *state
 ) {
-  TSSymbol candidate;
-  if (state->regex_at_branch_start) {
-    candidate = REGEX_LEADING_DUPLICATION_MARKER;
-  } else if (state->regex_duplication_state != REGEX_DUPLICATION_NONE) {
+  if (regex_at_branch_start(state)) {
+    return REGEX_LEADING_DUPLICATION_MARKER;
+  }
+  if (
+    state->regex_position !=
+    REGEX_AFTER_DUPLICATION_SYMBOL
 #if SED_REGEX_EXTENDED
-    if (
-      state->regex_duplication_state ==
-      REGEX_AFTER_DUPLICATION_SYMBOL &&
-      lexer->lookahead == '?'
-    ) {
-      return DUPLICATION_CONTEXT_SKIPPED;
-    }
+    && state->regex_position != REGEX_AFTER_REPETITION_MODIFIER
 #endif
-    candidate = REGEX_ADJACENT_DUPLICATION_MARKER;
-  } else {
-    return DUPLICATION_CONTEXT_SKIPPED;
-  }
-
-  if (!valid_symbols[candidate]) {
-    return DUPLICATION_CONTEXT_SKIPPED;
-  }
-
-  lexer->mark_end(lexer);
-  if (raw_duplication_symbol_follows(lexer, state)) {
-    *symbol = candidate;
-    return DUPLICATION_CONTEXT_TOKEN;
+  ) {
+    return ERROR_SENTINEL;
   }
-
 #if SED_REGEX_EXTENDED
-  if (lexer->lookahead != '{' || state->delimiter == '{') {
-    return DUPLICATION_CONTEXT_SKIPPED;
-  }
-  advance(lexer);
-  if (scan_regex_interval_tail(lexer, state, false)) {
-    *symbol = candidate;
-    return DUPLICATION_CONTEXT_TOKEN;
+  if (
+    state->regex_position ==
+    REGEX_AFTER_DUPLICATION_SYMBOL &&
+    lexer->lookahead == '?'
+  ) {
+    return ERROR_SENTINEL;
   }
 #else
-  if (lexer->lookahead != '\\') {
-    return DUPLICATION_CONTEXT_SKIPPED;
-  }
-  advance(lexer);
-  if (lexer->lookahead != '{' || state->delimiter == '{') {
-    return scan_regex_after_backslash(lexer, state, valid_symbols, symbol)
-      ? DUPLICATION_CONTEXT_TOKEN
-      : DUPLICATION_CONTEXT_CONSUMED;
-  }
-  advance(lexer);
-  if (scan_regex_interval_tail(lexer, state, true)) {
-    *symbol = candidate;
-    return DUPLICATION_CONTEXT_TOKEN;
-  }
+  (void)lexer;
 #endif
-
-  if (lexer->eof(lexer) && valid_symbols[REGEX_INCOMPLETE_INTERVAL]) {
-    emit_interval_issue(lexer, state, REGEX_INCOMPLETE_INTERVAL, symbol);
-    return DUPLICATION_CONTEXT_TOKEN;
-  }
-
-  if (!valid_symbols[REGEX_INVALID_INTERVAL]) {
-    *symbol = candidate;
-    return DUPLICATION_CONTEXT_TOKEN;
-  }
-  scan_invalid_interval_remainder(lexer, state);
-  emit_interval_issue(lexer, state, REGEX_INVALID_INTERVAL, symbol);
-  return DUPLICATION_CONTEXT_TOKEN;
+  return REGEX_ADJACENT_DUPLICATION_MARKER;
 }
 
 static bool raw_regex_operator_character(int32_t character) {
@@ -1646,10 +1321,9 @@ static bool scan_raw_regex_operator(
 
   if (character == '{') {
 #if SED_REGEX_EXTENDED
-    return scan_regex_interval(lexer, state, valid_symbols, symbol);
+    return scan_regex_interval_open(lexer, state, valid_symbols, symbol);
 #else
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_LITERAL, symbol);
+    return consume_as(lexer, valid_symbols, REGEX_LITERAL, symbol);
 #endif
   }
 
@@ -1661,7 +1335,7 @@ static bool scan_raw_regex_operator(
 #else
     return emit_symbol(
       valid_symbols,
-      state->regex_at_branch_start ? REGEX_LITERAL : REGEX_ZERO_OR_MORE,
+      regex_at_branch_start(state) ? REGEX_LITERAL : REGEX_ZERO_OR_MORE,
       symbol
     );
 #endif
@@ -1690,7 +1364,7 @@ static bool scan_raw_regex_operator(
 
   if (character == '?') {
     if (
-      state->regex_duplication_state ==
+      state->regex_position ==
       REGEX_AFTER_DUPLICATION_SYMBOL &&
       valid_symbols[REGEX_REPETITION_MODIFIER]
     ) {
@@ -1724,10 +1398,17 @@ static bool regex_delimiter_is_special(int32_t character) {
   }
 }
 
+// The QUOTED_CHAR sequences of XBD 9.5.1 for the selected RE.
 static bool escape_quotes_regex_syntax(int32_t character) {
   switch (character) {
 #if SED_REGEX_EXTENDED
-  case '}':
+  case '(':
+  case ')':
+  case '{':
+  case '}':
+  case '+':
+  case '?':
+  case '|':
 #endif
   case '.':
   case '*':
@@ -1747,11 +1428,12 @@ static bool scan_regex_escaped_delimiter(
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  const bool special = regex_delimiter_is_special(lexer->lookahead);
-  consume(lexer);
-  return emit_symbol(
+  return consume_as(
+    lexer,
     valid_symbols,
-    special ? REGEX_SPECIAL_ESCAPED_DELIMITER : REGEX_ESCAPED_DELIMITER,
+    regex_delimiter_is_special(lexer->lookahead)
+      ? REGEX_SPECIAL_ESCAPED_DELIMITER
+      : REGEX_ESCAPED_DELIMITER,
     symbol
   );
 }
@@ -1770,6 +1452,10 @@ static bool scan_regex_escape_after_backslash(
     return emit_symbol(valid_symbols, REGEX_FORBIDDEN_NEWLINE_ESCAPE, symbol);
   }
 
+  if (!source_character_is_valid(lexer->lookahead)) {
+    return emit_symbol(valid_symbols, ESCAPE_PREFIX, symbol);
+  }
+
   if (lexer->lookahead == state->delimiter) {
     return scan_regex_escaped_delimiter(lexer, valid_symbols, symbol);
   }
@@ -1777,103 +1463,89 @@ static bool scan_regex_escape_after_backslash(
 #if !SED_REGEX_EXTENDED
   if (lexer->lookahead == '}') {
     if (valid_symbols[REGEX_INTERVAL_CLOSE]) {
-      consume(lexer);
-      state->regex_interval_state = REGEX_INTERVAL_NONE;
-      return emit_symbol(valid_symbols, REGEX_INTERVAL_CLOSE, symbol);
+      return scan_regex_interval_close(lexer, state, valid_symbols, symbol);
     }
     if (valid_symbols[REGEX_UNMATCHED_INTERVAL_CLOSE]) {
-      consume(lexer);
-      return emit_symbol(valid_symbols, REGEX_UNMATCHED_INTERVAL_CLOSE, symbol);
+      return consume_as(
+        lexer,
+        valid_symbols,
+        REGEX_UNMATCHED_INTERVAL_CLOSE,
+        symbol
+      );
     }
   }
-#endif
 
-  if (lexer->lookahead == '(' || lexer->lookahead == ')') {
-#if !SED_REGEX_EXTENDED
-    const int32_t character = lexer->lookahead;
-#endif
-    consume(lexer);
-#if SED_REGEX_EXTENDED
-    return emit_symbol(valid_symbols, REGEX_QUOTED_ESCAPE, symbol);
-#else
-    return character == '('
-      ? emit_symbol(valid_symbols, REGEX_GROUP_OPEN, symbol)
-      : emit_symbol(
-          valid_symbols,
-          state->regex_group_depth > 0 ? REGEX_GROUP_CLOSE
-                                       : REGEX_UNMATCHED_GROUP_CLOSE,
-          symbol
-        );
-#endif
+  if (lexer->lookahead == '(') {
+    return consume_as(lexer, valid_symbols, REGEX_GROUP_OPEN, symbol);
+  }
+
+  if (lexer->lookahead == ')') {
+    return consume_as(
+      lexer,
+      valid_symbols,
+      state->regex_group_depth > 0 ? REGEX_GROUP_CLOSE
+                                   : REGEX_UNMATCHED_GROUP_CLOSE,
+      symbol
+    );
   }
 
   if (lexer->lookahead >= '1' && lexer->lookahead <= '9') {
-#if SED_REGEX_EXTENDED
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_NONPORTABLE_ESCAPE, symbol);
-#else
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_BACKREFERENCE, symbol);
-#endif
+    return consume_as(lexer, valid_symbols, REGEX_BACKREFERENCE, symbol);
   }
 
   if (lexer->lookahead == '{') {
-#if SED_REGEX_EXTENDED
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_QUOTED_ESCAPE, symbol);
-#else
-    return scan_regex_interval(lexer, state, valid_symbols, symbol);
-#endif
+    return scan_regex_interval_open(lexer, state, valid_symbols, symbol);
   }
 
-  if (
-    lexer->lookahead ==
-    '+' ||
-    lexer->lookahead ==
-    '?' ||
-    lexer->lookahead == '|'
-  ) {
-#if SED_REGEX_EXTENDED
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_QUOTED_ESCAPE, symbol);
-#else
-    const int32_t character = lexer->lookahead;
-    consume(lexer);
-    if (character == '|') {
-      return emit_symbol(valid_symbols, REGEX_BRE_VERTICAL_LINE_ESCAPE, symbol);
-    }
-    return emit_symbol(
+  if (lexer->lookahead == '|') {
+    return consume_as(
+      lexer,
       valid_symbols,
-      character == '?' ? REGEX_BRE_QUESTION_MARK_ESCAPE : REGEX_BRE_PLUS_ESCAPE,
+      REGEX_BRE_VERTICAL_LINE_ESCAPE,
       symbol
     );
-#endif
   }
 
+  if (lexer->lookahead == '?' || lexer->lookahead == '+') {
+    return consume_as(
+      lexer,
+      valid_symbols,
+      lexer->lookahead == '?' ? REGEX_BRE_QUESTION_MARK_ESCAPE
+                              : REGEX_BRE_PLUS_ESCAPE,
+      symbol
+    );
+  }
+#endif
+
   if (lexer->lookahead == 'n') {
-    consume(lexer);
-    return emit_symbol(valid_symbols, REGEX_NEWLINE_ESCAPE, symbol);
+    return consume_as(lexer, valid_symbols, REGEX_NEWLINE_ESCAPE, symbol);
   }
 
-  const TSSymbol candidate = escape_quotes_regex_syntax(lexer->lookahead)
-    ? REGEX_QUOTED_ESCAPE
-    : REGEX_NONPORTABLE_ESCAPE;
-  consume(lexer);
-  return emit_symbol(valid_symbols, candidate, symbol);
+  return consume_as(
+    lexer,
+    valid_symbols,
+    escape_quotes_regex_syntax(lexer->lookahead) ? REGEX_QUOTED_ESCAPE
+                                                 : REGEX_NONPORTABLE_ESCAPE,
+    symbol
+  );
 }
 
 #if !SED_REGEX_EXTENDED
+// Scans the escape after a backslash whose token end is marked before it:
+// "\)" first closes an empty subexpression unless ')' is the delimiter.
 static bool scan_regex_after_backslash(
   TSLexer *lexer,
   ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  if (lexer->lookahead == state->delimiter) {
-    return scan_regex_escaped_delimiter(lexer, valid_symbols, symbol);
-  }
-
-  if (lexer->lookahead == ')' && valid_symbols[EMPTY_SUBEXPRESSION_MARKER]) {
+  if (
+    lexer->lookahead ==
+    ')' &&
+    state->delimiter !=
+    ')' &&
+    valid_symbols[EMPTY_SUBEXPRESSION_MARKER]
+  ) {
     *symbol = EMPTY_SUBEXPRESSION_MARKER;
     return true;
   }
@@ -1885,7 +1557,7 @@ static bool scan_regex_after_backslash(
 
 static bool scan_regex_dup_count(
   TSLexer *lexer,
-  ScannerState *state,
+  const ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
@@ -1893,45 +1565,9 @@ static bool scan_regex_dup_count(
     consume(lexer);
   } while (is_digit(lexer->lookahead) && lexer->lookahead != state->delimiter);
 
-  if (state->regex_interval_state == REGEX_INTERVAL_EXPECT_MINIMUM) {
-    state->regex_interval_state = REGEX_INTERVAL_AFTER_MINIMUM;
-  } else if (state->regex_interval_state == REGEX_INTERVAL_EXPECT_MAXIMUM) {
-    state->regex_interval_state = REGEX_INTERVAL_AFTER_MAXIMUM;
-  }
-
   return emit_symbol(valid_symbols, REGEX_DUP_COUNT, symbol);
 }
 
-static bool
-scan_invalid_interval_remainder(TSLexer *lexer, ScannerState *state) {
-  bool consumed_character = false;
-  while (
-    !lexer->eof(lexer) &&
-    lexer->lookahead !=
-    '\n' &&
-    lexer->lookahead != state->delimiter
-  ) {
-    const int32_t character = lexer->lookahead;
-    consume(lexer);
-    consumed_character = true;
-    if (character == '}') {
-      break;
-    }
-    if (character != '\\' || lexer->eof(lexer) || lexer->lookahead == '\n') {
-      continue;
-    }
-    const int32_t escaped = lexer->lookahead;
-    consume(lexer);
-    if (!SED_REGEX_EXTENDED && escaped == '}') {
-      break;
-    }
-  }
-  if (consumed_character) {
-    state->regex_interval_state = REGEX_INTERVAL_NONE;
-  }
-  return consumed_character;
-}
-
 #if SED_REGEX_EXTENDED
 static bool scan_empty_regex_construct(
   TSLexer *lexer,
@@ -1946,7 +1582,7 @@ static bool scan_empty_regex_construct(
     ')' &&
     valid_symbols[EMPTY_SUBEXPRESSION_MARKER]
   ) {
-    return emit_missing_marker(
+    return emit_marker(
       lexer,
       valid_symbols,
       EMPTY_SUBEXPRESSION_MARKER,
@@ -1959,87 +1595,257 @@ static bool scan_empty_regex_construct(
       '|' ||
       (state->regex_group_depth > 0 && lexer->lookahead == ')'))
   ) {
-    return emit_missing_marker(
+    return emit_marker(lexer, valid_symbols, EMPTY_ALTERNATIVE_MARKER, symbol);
+  }
+  return false;
+}
+#endif
+
+static bool scan_regex_special_token(
+  TSLexer *lexer,
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  if (lexer->lookahead == '^') {
+    consume(lexer);
+#if !SED_REGEX_EXTENDED
+    if (
+      !regex_at_branch_start(state) ||
+      state->regex_position == REGEX_AFTER_ANCHOR
+    ) {
+      return emit_symbol(valid_symbols, REGEX_LITERAL, symbol);
+    }
+    if (state->regex_group_depth > 0) {
+      return emit_symbol(valid_symbols, REGEX_BRE_SUBEXPRESSION_CARET, symbol);
+    }
+#endif
+    return emit_symbol(valid_symbols, REGEX_BEGINNING_ANCHOR, symbol);
+  }
+
+  if (lexer->lookahead == '$') {
+    consume(lexer);
+#if !SED_REGEX_EXTENDED
+    if (lexer->lookahead == '\\') {
+      advance(lexer);
+      const bool closes_subexpression = state->regex_group_depth >
+        0 &&
+        lexer->lookahead ==
+        ')' &&
+        state->delimiter != ')';
+      return emit_symbol(
+        valid_symbols,
+        closes_subexpression ? REGEX_BRE_SUBEXPRESSION_DOLLAR : REGEX_LITERAL,
+        symbol
+      );
+    }
+    const bool at_branch_end = lexer->eof(lexer) ||
+      lexer->lookahead ==
+      '\n' ||
+      lexer->lookahead == state->delimiter;
+    if (!at_branch_end) {
+      return emit_symbol(valid_symbols, REGEX_LITERAL, symbol);
+    }
+#endif
+    return emit_symbol(valid_symbols, REGEX_END_ANCHOR, symbol);
+  }
+
+  if (lexer->lookahead == '.') {
+    return consume_as(lexer, valid_symbols, REGEX_PERIOD, symbol);
+  }
+
+  if (lexer->lookahead == '\\') {
+    consume(lexer);
+    return scan_regex_escape_after_backslash(
       lexer,
+      state,
       valid_symbols,
-      EMPTY_ALTERNATIVE_MARKER,
       symbol
     );
   }
+
+  if (raw_regex_operator_character(lexer->lookahead)) {
+    return scan_raw_regex_operator(lexer, state, valid_symbols, symbol);
+  }
+
+  if (lexer->lookahead == '[') {
+    consume(lexer);
+    reset_bracket_tracking(state);
+    state->regex_state = REGEX_BRACKET_FIRST;
+    return emit_symbol(valid_symbols, REGEX_BRACKET_OPEN, symbol);
+  }
+
   return false;
 }
-#endif
 
-static bool scan_regex_token(
+static bool scan_regex_bracket_close(
   TSLexer *lexer,
   ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  switch (scan_regex_duplication_context_marker(
-    lexer,
-    state,
-    valid_symbols,
-    symbol
-  )) {
-  case DUPLICATION_CONTEXT_TOKEN:
+  commit_pending_bracket_element(state);
+  if (
+    bracket_expression_is_ambiguous(state) &&
+    valid_symbols[AMBIGUOUS_BRACKET_EXPRESSION_MARKER]
+  ) {
+    lexer->mark_end(lexer);
+    *symbol = AMBIGUOUS_BRACKET_EXPRESSION_MARKER;
     return true;
-  case DUPLICATION_CONTEXT_CONSUMED:
-    return false;
-  case DUPLICATION_CONTEXT_SKIPPED:
-    break;
   }
 
-#if !SED_REGEX_EXTENDED
-  if (lexer->lookahead == '\\' && valid_symbols[EMPTY_SUBEXPRESSION_MARKER]) {
-    lexer->mark_end(lexer);
-    advance(lexer);
-    return scan_regex_after_backslash(lexer, state, valid_symbols, symbol);
+  consume(lexer);
+  state->regex_state = REGEX_OUTSIDE_BRACKET;
+  reset_bracket_tracking(state);
+  return emit_symbol(valid_symbols, REGEX_BRACKET_CLOSE, symbol);
+}
+
+static bool scan_regex_bracket_hyphen(
+  TSLexer *lexer,
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  lexer->mark_end(lexer);
+  advance(lexer);
+  if (
+    valid_symbols[NONPORTABLE_RANGE_START_MARKER] &&
+    !lexer->eof(lexer) &&
+    lexer->lookahead !=
+    '\n' &&
+    lexer->lookahead != ']'
+  ) {
+    *symbol = NONPORTABLE_RANGE_START_MARKER;
+    return true;
+  }
+  lexer->mark_end(lexer);
+
+  TSSymbol candidate;
+  if (valid_symbols[REGEX_BRACKET_RANGE_END_HYPHEN]) {
+    candidate = REGEX_BRACKET_RANGE_END_HYPHEN;
+  } else if (
+    lexer->eof(lexer) || lexer->lookahead == '\n' || lexer->lookahead == ']'
+  ) {
+    candidate = REGEX_BRACKET_TRAILING_HYPHEN;
+  } else {
+    candidate = REGEX_BRACKET_HYPHEN;
+  }
+  if (emit_symbol(valid_symbols, candidate, symbol)) {
+    if (candidate == REGEX_BRACKET_RANGE_END_HYPHEN) {
+      state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
+      state->regex_bracket_range_pending = false;
+      record_bracket_element(state, REGEX_BRACKET_PENDING_OTHER);
+    } else if (candidate == REGEX_BRACKET_TRAILING_HYPHEN) {
+      commit_pending_bracket_element(state);
+      record_bracket_element(state, REGEX_BRACKET_PENDING_OTHER);
+    } else {
+      state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
+      state->regex_bracket_range_pending = true;
+    }
+    return true;
   }
+  if (emit_symbol(valid_symbols, REGEX_SHARED_RANGE_ENDPOINT, symbol)) {
+    commit_pending_bracket_element(state);
+    state->regex_bracket_range_pending = false;
+    return true;
+  }
+  return false;
+}
+
+static bool scan_regex_bracket_special_token(
+  TSLexer *lexer,
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  if (state->regex_state == REGEX_BRACKET_FIRST && lexer->lookahead == '^') {
+    consume(lexer);
+    state->regex_state = REGEX_BRACKET_AFTER_CARET;
+    return emit_symbol(valid_symbols, REGEX_BRACKET_NEGATION, symbol);
+  }
+
+  if (state->regex_state == REGEX_BRACKET_BODY && lexer->lookahead == ']') {
+    return scan_regex_bracket_close(lexer, state, valid_symbols, symbol);
+  }
+
+  if (state->regex_state == REGEX_BRACKET_BODY && lexer->lookahead == '-') {
+    return scan_regex_bracket_hyphen(lexer, state, valid_symbols, symbol);
+  }
+
+  if (lexer->lookahead == '[') {
+    return scan_regex_bracket_opener(lexer, state, valid_symbols, symbol);
+  }
+
+  return false;
+}
+
+static bool scan_regex_token(
+  TSLexer *lexer,
+  ScannerState *state,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  // The marker precedes the duplication symbol, whose interval is then
+  // scanned like any other so that malformed content keeps its structure.
+  const TSSymbol marker = regex_duplication_context_marker(lexer, state);
+  if (marker != ERROR_SENTINEL && valid_symbols[marker]) {
+    lexer->mark_end(lexer);
+#if SED_REGEX_EXTENDED
+    if (
+      raw_duplication_symbol_follows(lexer, state) || lexer->lookahead == '{'
+    ) {
+      *symbol = marker;
+      return true;
+    }
 #else
+    if (raw_duplication_symbol_follows(lexer, state)) {
+      *symbol = marker;
+      return true;
+    }
+    if (lexer->lookahead == '\\') {
+      advance(lexer);
+      if (lexer->lookahead == '{' && state->delimiter != '{') {
+        *symbol = marker;
+        return true;
+      }
+      return scan_regex_after_backslash(lexer, state, valid_symbols, symbol);
+    }
+#endif
+  }
+
+#if SED_REGEX_EXTENDED
   if (scan_empty_regex_construct(lexer, state, valid_symbols, symbol)) {
     return true;
   }
 #endif
 
+  // The delimiter never reaches this point outside a bracket expression, so
+  // the interval tokens compare only against their own characters.
   if (
-    valid_symbols[REGEX_DUP_COUNT] &&
-    is_digit(lexer->lookahead) &&
-    lexer->lookahead != state->delimiter
+    state->regex_in_interval &&
+    !lexer->eof(lexer) &&
+    !source_character_is_valid(lexer->lookahead)
   ) {
+    return consume_as(lexer, valid_symbols, INVALID_CHARACTER, symbol);
+  }
+
+  if (valid_symbols[REGEX_DUP_COUNT] && is_digit(lexer->lookahead)) {
     return scan_regex_dup_count(lexer, state, valid_symbols, symbol);
   }
 
-  if (
-    valid_symbols[REGEX_INTERVAL_SEPARATOR] &&
-    lexer->lookahead ==
-    ',' &&
-    lexer->lookahead != state->delimiter
-  ) {
+  if (valid_symbols[REGEX_INTERVAL_SEPARATOR] && lexer->lookahead == ',') {
     consume(lexer);
-    state->regex_interval_state = REGEX_INTERVAL_EXPECT_MAXIMUM;
     *symbol = REGEX_INTERVAL_SEPARATOR;
     return true;
   }
 
 #if SED_REGEX_EXTENDED
-  if (
-    valid_symbols[REGEX_INTERVAL_CLOSE] &&
-    lexer->lookahead ==
-    '}' &&
-    lexer->lookahead != state->delimiter
-  ) {
-    consume(lexer);
-    state->regex_interval_state = REGEX_INTERVAL_NONE;
-    *symbol = REGEX_INTERVAL_CLOSE;
-    return true;
+  if (valid_symbols[REGEX_INTERVAL_CLOSE] && lexer->lookahead == '}') {
+    return scan_regex_interval_close(lexer, state, valid_symbols, symbol);
   }
 #else
-  if (
-    state->regex_interval_state !=
-    REGEX_INTERVAL_NONE &&
-    lexer->lookahead == '\\'
-  ) {
+  if (state->regex_in_interval && lexer->lookahead == '\\') {
+    lexer->mark_end(lexer);
     advance(lexer);
     if (
       valid_symbols[REGEX_INTERVAL_CLOSE] &&
@@ -2047,46 +1853,38 @@ static bool scan_regex_token(
       '}' &&
       lexer->lookahead != state->delimiter
     ) {
-      consume(lexer);
-      state->regex_interval_state = REGEX_INTERVAL_NONE;
-      *symbol = REGEX_INTERVAL_CLOSE;
-      return true;
+      return scan_regex_interval_close(lexer, state, valid_symbols, symbol);
     }
     if (lexer->eof(lexer) && valid_symbols[REGEX_INCOMPLETE_INTERVAL]) {
-      return emit_interval_issue(
-        lexer,
+      lexer->mark_end(lexer);
+      return end_interval(
         state,
+        valid_symbols,
         REGEX_INCOMPLETE_INTERVAL,
         symbol
       );
     }
-    if (!valid_symbols[REGEX_INVALID_INTERVAL]) {
-      return false;
-    }
-    if (lexer->lookahead == '}') {
-      advance(lexer);
-    } else {
-      advance_past_escaped_character(lexer);
-      scan_invalid_interval_remainder(lexer, state);
+    // The escape is the first unit of malformed content unless it ends the
+    // content, in which case the issue is empty and the escape follows it.
+    if (!interval_escape_ends_content(state, lexer->lookahead)) {
+      finish_malformed_escape(lexer);
+      scan_malformed_interval_content(lexer, state);
     }
-    return emit_interval_issue(lexer, state, REGEX_INVALID_INTERVAL, symbol);
+    return emit_malformed_interval(lexer, state, valid_symbols, symbol);
   }
 #endif
 
-  if (
-    state->regex_interval_state !=
-    REGEX_INTERVAL_NONE &&
-    valid_symbols[REGEX_INVALID_INTERVAL] &&
-    scan_invalid_interval_remainder(lexer, state)
-  ) {
-    *symbol = REGEX_INVALID_INTERVAL;
-    return true;
+  if (state->regex_in_interval && valid_symbols[REGEX_INVALID_INTERVAL]) {
+    lexer->mark_end(lexer);
+    scan_malformed_interval_content(lexer, state);
+    return emit_malformed_interval(lexer, state, valid_symbols, symbol);
   }
 
   const bool inside_bracket = regex_is_inside_bracket(state);
   if (inside_bracket) {
     if (
       valid_symbols[REGEX_CLASS_NAME] ||
+      valid_symbols[REGEX_INVALID_CLASS_NAME] ||
       valid_symbols[REGEX_COLL_ELEM_SINGLE] ||
       valid_symbols[REGEX_COLL_ELEM_MULTI] ||
       valid_symbols[REGEX_META_CHAR]
@@ -2094,7 +1892,6 @@ static bool scan_regex_token(
       return scan_regex_bracket_term_content(
         lexer,
         state,
-        bracket_term_close_marker(state->regex_bracket_term_state),
         valid_symbols,
         symbol
       );
@@ -2112,212 +1909,42 @@ static bool scan_regex_token(
       *symbol = REGEX_MALFORMED_BRACKET_TERM;
       return true;
     }
-    if (valid_symbols[REGEX_COLON_CLOSE] && lexer->lookahead == ':') {
-      return scan_regex_bracket_term_close(
-        lexer,
-        state,
-        ':',
-        REGEX_COLON_CLOSE,
-        valid_symbols,
-        symbol
-      );
-    }
-    if (valid_symbols[REGEX_DOT_CLOSE] && lexer->lookahead == '.') {
-      return scan_regex_bracket_term_close(
-        lexer,
-        state,
-        '.',
-        REGEX_DOT_CLOSE,
-        valid_symbols,
-        symbol
-      );
-    }
-    if (valid_symbols[REGEX_EQUAL_CLOSE] && lexer->lookahead == '=') {
-      return scan_regex_bracket_term_close(
-        lexer,
-        state,
-        '=',
-        REGEX_EQUAL_CLOSE,
-        valid_symbols,
-        symbol
-      );
-    }
-  }
-
-  const enum LiteralScanResult literal_result =
-    scan_regex_literal(lexer, state);
-  if (literal_result == LITERAL_SCAN_TOKEN) {
-    return emit_symbol(
-      valid_symbols,
-      inside_bracket ? REGEX_BRACKET_LITERAL : REGEX_LITERAL,
-      symbol
-    );
-  }
-  if (literal_result == LITERAL_SCAN_LINE_END) {
-    return emit_unterminated(
-      state,
-      valid_symbols,
-      regex_unterminated_symbol(state->mode, lexer->eof(lexer)),
-      symbol
-    );
-  }
-
-  if (state->regex_state == REGEX_OUTSIDE_BRACKET) {
-    if (lexer->lookahead == '^') {
-      consume(lexer);
-#if !SED_REGEX_EXTENDED
-      if (
-        state->regex_group_depth >
-        0 &&
-        state->regex_at_branch_start &&
-        !state->regex_after_anchor
-      ) {
-        return emit_symbol(
-          valid_symbols,
-          REGEX_BRE_SUBEXPRESSION_CARET,
-          symbol
-        );
-      }
-#endif
-      const bool is_beginning_anchor = SED_REGEX_EXTENDED ||
-        (state->regex_at_branch_start && !state->regex_after_anchor);
-      const TSSymbol candidate =
-        is_beginning_anchor ? REGEX_BEGINNING_ANCHOR : REGEX_LITERAL;
-      return emit_symbol(valid_symbols, candidate, symbol);
-    }
-
-    if (lexer->lookahead == '$') {
-      bool inspected_bre_escape = false;
-      consume(lexer);
-#if !SED_REGEX_EXTENDED
-      if (lexer->lookahead == '\\') {
-        inspected_bre_escape = true;
-        advance(lexer);
-        if (state->regex_group_depth > 0 && lexer->lookahead == ')') {
-          return emit_symbol(
-            valid_symbols,
-            REGEX_BRE_SUBEXPRESSION_DOLLAR,
-            symbol
-          );
-        }
-      }
-#endif
-      const bool at_branch_end = SED_REGEX_EXTENDED ||
-        (!inspected_bre_escape &&
-          (lexer->eof(lexer) ||
-            lexer->lookahead ==
-            '\n' ||
-            lexer->lookahead == state->delimiter));
-      const TSSymbol candidate =
-        at_branch_end ? REGEX_END_ANCHOR : REGEX_LITERAL;
-      return emit_symbol(valid_symbols, candidate, symbol);
-    }
-
-    if (lexer->lookahead == '.') {
-      consume(lexer);
-      return emit_symbol(valid_symbols, REGEX_PERIOD, symbol);
-    }
-
-    if (lexer->lookahead == '\\') {
-      advance(lexer);
-      lexer->mark_end(lexer);
-      return scan_regex_escape_after_backslash(
-        lexer,
-        state,
-        valid_symbols,
-        symbol
-      );
-    }
-
-    if (raw_regex_operator_character(lexer->lookahead)) {
-      return scan_raw_regex_operator(lexer, state, valid_symbols, symbol);
-    }
-
-    if (lexer->lookahead == '[') {
-      consume(lexer);
-      reset_bracket_tracking(state);
-      state->regex_state = REGEX_BRACKET_FIRST;
-      return emit_symbol(valid_symbols, REGEX_BRACKET_OPEN, symbol);
-    }
-
-    return false;
-  }
-
-  if (state->regex_state == REGEX_BRACKET_FIRST && lexer->lookahead == '^') {
-    consume(lexer);
-    state->regex_state = REGEX_BRACKET_AFTER_CARET;
-    return emit_symbol(valid_symbols, REGEX_BRACKET_NEGATION, symbol);
-  }
-
-  if (state->regex_state == REGEX_BRACKET_BODY && lexer->lookahead == ']') {
-    commit_pending_bracket_element(state);
-    if (
-      bracket_expression_is_ambiguous(state) &&
-      valid_symbols[AMBIGUOUS_BRACKET_EXPRESSION_MARKER]
-    ) {
-      lexer->mark_end(lexer);
-      *symbol = AMBIGUOUS_BRACKET_EXPRESSION_MARKER;
-      return true;
-    }
-
-    consume(lexer);
-    state->regex_state = REGEX_OUTSIDE_BRACKET;
-    reset_bracket_tracking(state);
-    return emit_symbol(valid_symbols, REGEX_BRACKET_CLOSE, symbol);
-  }
-
-  if (state->regex_state == REGEX_BRACKET_BODY && lexer->lookahead == '-') {
-    lexer->mark_end(lexer);
-    advance(lexer);
     if (
-      valid_symbols[NONPORTABLE_RANGE_START_MARKER] &&
-      !lexer->eof(lexer) &&
-      lexer->lookahead !=
-      '\n' &&
-      lexer->lookahead != ']'
-    ) {
-      *symbol = NONPORTABLE_RANGE_START_MARKER;
-      return true;
-    }
-    lexer->mark_end(lexer);
-
-    TSSymbol candidate;
-    if (valid_symbols[REGEX_BRACKET_RANGE_END_HYPHEN]) {
-      candidate = REGEX_BRACKET_RANGE_END_HYPHEN;
-    } else if (
-      lexer->eof(lexer) || lexer->lookahead == '\n' || lexer->lookahead == ']'
+      state->regex_bracket_term_state !=
+      REGEX_BRACKET_TERM_NONE &&
+      valid_symbols[bracket_terms[state->regex_bracket_term_state]
+          .close_symbol] &&
+      lexer->lookahead == bracket_terms[state->regex_bracket_term_state].marker
     ) {
-      candidate = REGEX_BRACKET_TRAILING_HYPHEN;
-    } else {
-      candidate = REGEX_BRACKET_HYPHEN;
-    }
-    if (emit_symbol(valid_symbols, candidate, symbol)) {
-      if (candidate == REGEX_BRACKET_RANGE_END_HYPHEN) {
-        state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
-        state->regex_bracket_range_pending = false;
-        record_bracket_element(state, REGEX_BRACKET_PENDING_OTHER);
-      } else if (candidate == REGEX_BRACKET_TRAILING_HYPHEN) {
-        commit_pending_bracket_element(state);
-        record_bracket_element(state, REGEX_BRACKET_PENDING_OTHER);
-      } else {
-        state->regex_bracket_pending_element = REGEX_BRACKET_PENDING_NONE;
-        state->regex_bracket_range_pending = true;
-      }
-      return true;
-    }
-    if (emit_symbol(valid_symbols, REGEX_SHARED_RANGE_ENDPOINT, symbol)) {
-      commit_pending_bracket_element(state);
-      state->regex_bracket_range_pending = false;
-      return true;
+      return scan_regex_bracket_term_close(lexer, state, valid_symbols, symbol);
     }
-    return false;
   }
 
-  if (lexer->lookahead == '[') {
-    return scan_regex_bracket_opener(lexer, state, valid_symbols, symbol);
+  const enum LiteralScanResult literal_result =
+    scan_regex_literal(lexer, state);
+  if (literal_result == LITERAL_SCAN_INVALID_CHARACTER) {
+    return emit_symbol(valid_symbols, INVALID_CHARACTER, symbol);
+  }
+  if (literal_result == LITERAL_SCAN_TOKEN) {
+    return emit_symbol(
+      valid_symbols,
+      inside_bracket ? REGEX_BRACKET_LITERAL : REGEX_LITERAL,
+      symbol
+    );
+  }
+  if (literal_result == LITERAL_SCAN_LINE_END) {
+    return end_mode(
+      state,
+      valid_symbols,
+      unterminated_mode_symbol(state->mode, lexer->eof(lexer)),
+      symbol
+    );
   }
 
-  return false;
+  if (state->regex_state == REGEX_OUTSIDE_BRACKET) {
+    return scan_regex_special_token(lexer, state, valid_symbols, symbol);
+  }
+  return scan_regex_bracket_special_token(lexer, state, valid_symbols, symbol);
 }
 
 static enum LiteralScanResult scan_operand_literal(
@@ -2333,6 +1960,10 @@ static enum LiteralScanResult scan_operand_literal(
       return consumed ? LITERAL_SCAN_TOKEN : LITERAL_SCAN_LINE_END;
     }
 
+    if (lexer->lookahead == 0) {
+      return consumed ? LITERAL_SCAN_TOKEN : LITERAL_SCAN_INVALID_CHARACTER;
+    }
+
     if (
       lexer->lookahead ==
       state->delimiter ||
@@ -2340,6 +1971,10 @@ static enum LiteralScanResult scan_operand_literal(
       '\\' ||
       (ampersand_is_special && lexer->lookahead == '&')
     ) {
+      if (consumed && lexer->lookahead == state->delimiter) {
+        // Track every byte of the delimiter as lookahead, outside the literal.
+        advance(lexer);
+      }
       return consumed ? LITERAL_SCAN_TOKEN : LITERAL_SCAN_NONE;
     }
 
@@ -2354,16 +1989,23 @@ static bool scan_replacement_escape(
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  advance(lexer);
-  lexer->mark_end(lexer);
+  consume(lexer);
 
   if (lexer->eof(lexer)) {
     return emit_symbol(valid_symbols, REPLACEMENT_INCOMPLETE_ESCAPE, symbol);
   }
 
+  if (lexer->lookahead == 0) {
+    return emit_symbol(valid_symbols, ESCAPE_PREFIX, symbol);
+  }
+
   if (lexer->lookahead == '\n') {
-    consume(lexer);
-    return emit_symbol(valid_symbols, REPLACEMENT_ESCAPED_NEWLINE, symbol);
+    return consume_as(
+      lexer,
+      valid_symbols,
+      REPLACEMENT_ESCAPED_NEWLINE,
+      symbol
+    );
   }
 
   TSSymbol candidate = REPLACEMENT_ESCAPE_SEQUENCE;
@@ -2376,8 +2018,12 @@ static bool scan_replacement_escape(
     '\\' &&
     !is_digit(lexer->lookahead)
   ) {
-    consume(lexer);
-    return emit_symbol(valid_symbols, REPLACEMENT_NONPORTABLE_ESCAPE, symbol);
+    return consume_as(
+      lexer,
+      valid_symbols,
+      REPLACEMENT_NONPORTABLE_ESCAPE,
+      symbol
+    );
   }
   if (lexer->lookahead == state->delimiter) {
     candidate = state->delimiter == '&'
@@ -2387,51 +2033,7 @@ static bool scan_replacement_escape(
     candidate = REPLACEMENT_BACKREFERENCE;
   }
 
-  consume(lexer);
-  return emit_symbol(valid_symbols, candidate, symbol);
-}
-
-static bool scan_replacement_token(
-  TSLexer *lexer,
-  ScannerState *state,
-  const bool *valid_symbols,
-  TSSymbol *symbol
-) {
-  const enum LiteralScanResult literal_result =
-    scan_operand_literal(lexer, state, true);
-  if (literal_result == LITERAL_SCAN_TOKEN) {
-    return emit_symbol(valid_symbols, REPLACEMENT_LITERAL, symbol);
-  }
-  if (literal_result == LITERAL_SCAN_LINE_END) {
-    return emit_unterminated(
-      state,
-      valid_symbols,
-      lexer->eof(lexer) ? REPLACEMENT_UNTERMINATED
-                        : REPLACEMENT_LINE_UNTERMINATED,
-      symbol
-    );
-  }
-
-  if (lexer->lookahead == '\\') {
-    return scan_replacement_escape(lexer, state, valid_symbols, symbol);
-  }
-
-  if (lexer->lookahead == '&') {
-    consume(lexer);
-    return emit_symbol(valid_symbols, REPLACEMENT_MATCH_REFERENCE, symbol);
-  }
-
-  return false;
-}
-
-static TSSymbol
-translate_unterminated_symbol(enum ScannerMode mode, bool at_end_of_source) {
-  if (mode == MODE_TRANSLATE_SOURCE) {
-    return at_end_of_source ? TRANSLATE_UNTERMINATED_SOURCE
-                            : TRANSLATE_LINE_UNTERMINATED_SOURCE;
-  }
-  return at_end_of_source ? TRANSLATE_UNTERMINATED_DESTINATION
-                          : TRANSLATE_LINE_UNTERMINATED_DESTINATION;
+  return consume_as(lexer, valid_symbols, candidate, symbol);
 }
 
 static bool scan_translate_escape(
@@ -2440,56 +2042,73 @@ static bool scan_translate_escape(
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  advance(lexer);
-  lexer->mark_end(lexer);
+  consume(lexer);
 
   if (lexer->eof(lexer)) {
     return emit_symbol(valid_symbols, TRANSLATE_INCOMPLETE_ESCAPE, symbol);
   }
 
+  if (lexer->lookahead == 0) {
+    return emit_symbol(valid_symbols, ESCAPE_PREFIX, symbol);
+  }
+
   if (lexer->lookahead == '\n') {
     return emit_symbol(valid_symbols, TRANSLATE_NONPORTABLE_ESCAPE, symbol);
   }
 
-  if (
-    lexer->lookahead !=
-    'n' &&
-    lexer->lookahead !=
-    '\\' &&
-    (lexer->lookahead != state->delimiter || state->delimiter == 'n')
-  ) {
-    consume(lexer);
-    return emit_symbol(valid_symbols, TRANSLATE_NONPORTABLE_ESCAPE, symbol);
+  // "\n" is a newline even when 'n' is the delimiter.
+  TSSymbol candidate;
+  if (lexer->lookahead == 'n' || lexer->lookahead == '\\') {
+    candidate = TRANSLATE_ESCAPE;
+  } else if (lexer->lookahead == state->delimiter) {
+    candidate = TRANSLATE_ESCAPED_DELIMITER;
+  } else {
+    candidate = TRANSLATE_NONPORTABLE_ESCAPE;
   }
-  const TSSymbol candidate = lexer->lookahead == 'n' || lexer->lookahead == '\\'
-    ? TRANSLATE_ESCAPE
-    : TRANSLATE_ESCAPED_DELIMITER;
-  consume(lexer);
-  return emit_symbol(valid_symbols, candidate, symbol);
+  return consume_as(lexer, valid_symbols, candidate, symbol);
 }
 
-static bool scan_translate_token(
+static bool scan_operand_token(
   TSLexer *lexer,
   ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
+  const bool is_replacement = state->mode == MODE_SUBSTITUTE_REPLACEMENT;
   const enum LiteralScanResult literal_result =
-    scan_operand_literal(lexer, state, false);
+    scan_operand_literal(lexer, state, is_replacement);
   if (literal_result == LITERAL_SCAN_TOKEN) {
-    return emit_symbol(valid_symbols, TRANSLATE_LITERAL, symbol);
+    return emit_symbol(
+      valid_symbols,
+      is_replacement ? REPLACEMENT_LITERAL : TRANSLATE_LITERAL,
+      symbol
+    );
+  }
+  if (literal_result == LITERAL_SCAN_INVALID_CHARACTER) {
+    return consume_as(lexer, valid_symbols, NUL_CHARACTER, symbol);
   }
   if (literal_result == LITERAL_SCAN_LINE_END) {
-    return emit_unterminated(
+    return end_mode(
       state,
       valid_symbols,
-      translate_unterminated_symbol(state->mode, lexer->eof(lexer)),
+      unterminated_mode_symbol(state->mode, lexer->eof(lexer)),
       symbol
     );
   }
 
   if (lexer->lookahead == '\\') {
-    return scan_translate_escape(lexer, state, valid_symbols, symbol);
+    return is_replacement
+      ? scan_replacement_escape(lexer, state, valid_symbols, symbol)
+      : scan_translate_escape(lexer, state, valid_symbols, symbol);
+  }
+
+  if (is_replacement && lexer->lookahead == '&') {
+    return consume_as(
+      lexer,
+      valid_symbols,
+      REPLACEMENT_MATCH_REFERENCE,
+      symbol
+    );
   }
 
   return false;
@@ -2501,26 +2120,6 @@ static bool scan_regex_recovery_marker(
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-#if !SED_REGEX_EXTENDED
-  if (
-    emit_missing_marker(
-      lexer,
-      valid_symbols,
-      BRE_VERTICAL_LINE_ESCAPE_MARKER,
-      symbol
-    ) ||
-    emit_missing_marker(
-      lexer,
-      valid_symbols,
-      BRE_QUESTION_MARK_ESCAPE_MARKER,
-      symbol
-    ) ||
-    emit_missing_marker(lexer, valid_symbols, BRE_PLUS_ESCAPE_MARKER, symbol)
-  ) {
-    return true;
-  }
-#endif
-
   const bool at_line_boundary = lexer->eof(lexer) || lexer->lookahead == '\n';
   const bool at_regex_end =
     at_line_boundary || lexer->lookahead == state->delimiter;
@@ -2530,9 +2129,12 @@ static bool scan_regex_recovery_marker(
     REGEX_OUTSIDE_BRACKET &&
     state->regex_group_depth >
     0 &&
-    !state->regex_after_alternation &&
+#if SED_REGEX_EXTENDED
+    state->regex_position !=
+    REGEX_AFTER_ALTERNATION &&
+#endif
     at_regex_end &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? MISSING_SUBEXPRESSION_MARKER
@@ -2548,7 +2150,7 @@ static bool scan_regex_recovery_marker(
       REGEX_BRACKET_FIRST ||
       state->regex_state == REGEX_BRACKET_AFTER_CARET) &&
     at_line_boundary &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? INCOMPLETE_BRACKET_LIST_MARKER
@@ -2563,7 +2165,7 @@ static bool scan_regex_recovery_marker(
     state->regex_bracket_term_state !=
     REGEX_BRACKET_TERM_NONE &&
     at_line_boundary &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? REGEX_INCOMPLETE_BRACKET_TERM
@@ -2579,7 +2181,7 @@ static bool scan_regex_recovery_marker(
   if (
     regex_is_inside_bracket(state) &&
     at_line_boundary &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? INCOMPLETE_BRACKET_EXPRESSION_MARKER
@@ -2596,9 +2198,10 @@ static bool scan_regex_recovery_marker(
   if (
     state->regex_state ==
     REGEX_OUTSIDE_BRACKET &&
-    state->regex_after_alternation &&
+    state->regex_position ==
+    REGEX_AFTER_ALTERNATION &&
     at_regex_end &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? INCOMPLETE_ALTERNATIVE_MARKER
@@ -2606,27 +2209,22 @@ static bool scan_regex_recovery_marker(
       symbol
     )
   ) {
-    state->regex_after_alternation = false;
+    state->regex_position = REGEX_AT_BRANCH_START;
     return true;
   }
 #endif
 
   if (
-    state->regex_interval_state !=
-    REGEX_INTERVAL_NONE &&
-    (at_regex_end
-#if !SED_REGEX_EXTENDED
-     || (state->delimiter == '}' && lexer->lookahead == '\\')
-#endif
-    ) &&
-    emit_missing_marker(
+    state->regex_in_interval &&
+    at_regex_end &&
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? REGEX_INCOMPLETE_INTERVAL : REGEX_INVALID_INTERVAL,
       symbol
     )
   ) {
-    state->regex_interval_state = REGEX_INTERVAL_NONE;
+    state->regex_in_interval = false;
     return true;
   }
 
@@ -2636,7 +2234,7 @@ static bool scan_regex_recovery_marker(
     state->regex_group_depth >
     0 &&
     at_line_boundary &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? REGEX_INCOMPLETE_GROUP : REGEX_UNCLOSED_GROUP,
@@ -2655,60 +2253,97 @@ static TSSymbol missing_text_introducer_symbol(const TSLexer *lexer) {
                            : NONCONFORMING_MISSING_TEXT_INTRODUCER_MARKER;
 }
 
+static bool
+scan_right_brace(TSLexer *lexer, const bool *valid_symbols, TSSymbol *symbol) {
+  skip_blanks(lexer);
+
+  if (lexer->lookahead == '}') {
+    consume(lexer);
+    *symbol = RIGHT_BRACE;
+    return true;
+  }
+  if (lexer->eof(lexer)) {
+    return emit_marker(
+      lexer,
+      valid_symbols,
+      MISSING_CLOSING_BRACE_MARKER,
+      symbol
+    );
+  }
+  return false;
+}
+
 static bool scan_command_token(
   TSLexer *lexer,
   ScannerState *state,
   const bool *valid_symbols,
   TSSymbol *symbol
 ) {
-  if (valid_symbols[LINE_WORD] && scan_to_physical_line_end(lexer, false)) {
+  if (
+    valid_symbols[EMPTY_COMMAND_MARKER] &&
+    (lexer->lookahead == ';' || lexer->lookahead == '\n')
+  ) {
+    return emit_marker(lexer, valid_symbols, EMPTY_COMMAND_MARKER, symbol);
+  }
+
+  if (
+    valid_symbols[NUL_CHARACTER] && !lexer->eof(lexer) && lexer->lookahead == 0
+  ) {
+    return consume_as(lexer, valid_symbols, NUL_CHARACTER, symbol);
+  }
+
+  if (
+    valid_symbols[SUBSTITUTION_WFILE_CONTINUATION] &&
+    scan_line_rest(lexer, true)
+  ) {
+    *symbol = SUBSTITUTION_WFILE_CONTINUATION;
+    return true;
+  }
+
+  if (valid_symbols[LINE_WORD] && scan_line_rest(lexer, false)) {
     *symbol = LINE_WORD;
     return true;
   }
 
+  // The label separator of b and t is exactly one space. It is read before
+  // the post-blank recovery markers, which would otherwise claim the blank in
+  // front of a label that starts with a closing brace.
+  if (valid_symbols[ARGUMENT_SEPARATOR] && lexer->lookahead == ' ') {
+    consume(lexer);
+    *symbol = ARGUMENT_SEPARATOR;
+    return true;
+  }
+
   if (valid_symbols[FLAG_AFTER_WRITE_MARKER]) {
-    const enum FlagAfterWriteScan scan = scan_flag_after_write_marker(lexer);
-    if (scan == FLAG_AFTER_WRITE_MATCH) {
+    switch (scan_flag_after_write_marker(lexer)) {
+    case FLAG_AFTER_WRITE_MATCH:
       *symbol = FLAG_AFTER_WRITE_MARKER;
       return true;
-    }
-    if (
-      scan ==
-      FLAG_AFTER_WRITE_FALLBACK &&
-      valid_symbols[OMITTED_FILE_SEPARATOR_MARKER]
-    ) {
-      *symbol = OMITTED_FILE_SEPARATOR_MARKER;
-      return true;
-    }
-    if (scan == FLAG_AFTER_WRITE_FALLBACK) {
-      return false;
+    case FLAG_AFTER_WRITE_FALLBACK:
+      return emit_symbol(valid_symbols, OMITTED_FILE_SEPARATOR_MARKER, symbol);
+    case FLAG_AFTER_WRITE_NONE:
+      break;
     }
   }
 
   if (
     valid_symbols[SUBSTITUTION_WFILE_ARGUMENT] &&
-    scan_substitution_wfile_argument(lexer)
+    scan_file_argument(lexer, true)
   ) {
     *symbol = SUBSTITUTION_WFILE_ARGUMENT;
     return true;
   }
 
-  if (valid_symbols[FILE_ARGUMENT] && scan_file_argument(lexer)) {
+  if (valid_symbols[FILE_ARGUMENT] && scan_file_argument(lexer, false)) {
     *symbol = FILE_ARGUMENT;
     return true;
   }
 
   if (
     valid_symbols[INVALID_SUBSTITUTION_FLAG] &&
+    !at_command_boundary(lexer) &&
     !is_blank(lexer->lookahead) &&
-    !is_substitution_flag_character(lexer->lookahead) &&
-    lexer->lookahead !=
-    ';' &&
-    lexer->lookahead !=
-    '}' &&
-    lexer->lookahead !=
-    '\n' &&
-    !lexer->eof(lexer)
+    !is_substitution_flag_character(lexer->lookahead)
   ) {
     consume(lexer);
     *symbol = INVALID_SUBSTITUTION_FLAG;
@@ -2720,9 +2355,13 @@ static bool scan_command_token(
       *symbol = TEXT_COMMAND_START;
       return true;
     }
+    if (lexer->eof(lexer)) {
+      lexer->mark_end(lexer);
+      return emit_symbol(valid_symbols, TEXT_INCOMPLETE_INTRODUCER, symbol);
+    }
     return emit_symbol(
       valid_symbols,
-      missing_text_introducer_symbol(lexer),
+      NONCONFORMING_MISSING_TEXT_INTRODUCER_MARKER,
       symbol
     );
   }
@@ -2733,77 +2372,72 @@ static bool scan_command_token(
     return true;
   }
 
-  if (valid_symbols[COMMENT_TEXT] && scan_to_physical_line_end(lexer, false)) {
+  if (valid_symbols[COMMENT_TEXT] && scan_line_rest(lexer, false)) {
     *symbol = COMMENT_TEXT;
     return true;
   }
 
-  // Preserve an address interpretation before reserved-function recovery.
   if (
-    valid_symbols[MISSING_ADDRESS_SEPARATOR_MARKER] && can_start_address(lexer)
+    valid_symbols[INVALID_CHARACTER] &&
+    !lexer->eof(lexer) &&
+    !source_character_is_valid(lexer->lookahead)
   ) {
-    return emit_missing_marker(
-      lexer,
-      valid_symbols,
-      MISSING_ADDRESS_SEPARATOR_MARKER,
-      symbol
-    );
+    return consume_as(lexer, valid_symbols, INVALID_CHARACTER, symbol);
   }
 
+  // Preserve an address interpretation before reserved-function recovery.
   if (
-    valid_symbols[RESERVED_UNKNOWN_FUNCTION_TOKEN] &&
-    scan_reserved_unknown_function(lexer)
+    can_start_address(lexer) &&
+    emit_marker(lexer, valid_symbols, MISSING_ADDRESS_SEPARATOR_MARKER, symbol)
   ) {
-    *symbol = RESERVED_UNKNOWN_FUNCTION_TOKEN;
     return true;
   }
 
   if (
-    valid_symbols[REGEX_ADDRESS_START] &&
-    lexer->lookahead ==
-    '/' &&
-    scan_simple_delimiter(lexer, state, MODE_REGEX_ADDRESS)
+    valid_symbols[RESERVED_UNKNOWN_FUNCTION_TOKEN] && can_start_address(lexer)
   ) {
-    *symbol = REGEX_ADDRESS_START;
+    consume(lexer);
+    *symbol = RESERVED_UNKNOWN_FUNCTION_TOKEN;
     return true;
   }
 
-  if (valid_symbols[ESCAPED_REGEX_ADDRESS_START]) {
-    if (scan_simple_delimiter(lexer, state, MODE_REGEX_ADDRESS)) {
-      *symbol = ESCAPED_REGEX_ADDRESS_START;
-      return true;
-    }
-  }
-
-  if (valid_symbols[SUBSTITUTE_START]) {
-    if (scan_simple_delimiter(lexer, state, MODE_SUBSTITUTE_PATTERN)) {
-      *symbol = SUBSTITUTE_START;
-      return true;
-    }
-  }
-
-  if (valid_symbols[TRANSLATE_START]) {
-    if (scan_simple_delimiter(lexer, state, MODE_TRANSLATE_SOURCE)) {
-      *symbol = TRANSLATE_START;
+  static const struct {
+    TSSymbol symbol;
+    enum ScannerMode mode;
+    int32_t required_delimiter;
+  } delimited_openers[] = {
+    {REGEX_ADDRESS_START, MODE_REGEX_ADDRESS, '/'},
+    {ESCAPED_REGEX_ADDRESS_START, MODE_REGEX_ADDRESS, 0},
+    {SUBSTITUTE_START, MODE_SUBSTITUTE_PATTERN, 0},
+    {TRANSLATE_START, MODE_TRANSLATE_SOURCE, 0},
+  };
+  for (
+    unsigned index = 0;
+    index < sizeof(delimited_openers) / sizeof(delimited_openers[0]);
+    index++
+  ) {
+    const int32_t required = delimited_openers[index].required_delimiter;
+    if (
+      valid_symbols[delimited_openers[index].symbol] &&
+      (required == 0 || lexer->lookahead == required) &&
+      scan_simple_delimiter(lexer, state, delimited_openers[index].mode)
+    ) {
+      *symbol = delimited_openers[index].symbol;
       return true;
     }
   }
 
-  if (valid_symbols[RIGHT_BRACE] && scan_right_brace(lexer, state)) {
-    *symbol = RIGHT_BRACE;
-    return true;
+  if (
+    valid_symbols[RIGHT_BRACE] &&
+    (is_blank(lexer->lookahead) || lexer->lookahead == '}')
+  ) {
+    return scan_right_brace(lexer, valid_symbols, symbol);
   }
 
   if (
-    valid_symbols[OMITTED_FIRST_ADDRESS_MARKER] &&
     lexer->lookahead ==
     ',' &&
-    emit_missing_marker(
-      lexer,
-      valid_symbols,
-      OMITTED_FIRST_ADDRESS_MARKER,
-      symbol
-    )
+    emit_marker(lexer, valid_symbols, OMITTED_FIRST_ADDRESS_MARKER, symbol)
   ) {
     return true;
   }
@@ -2814,7 +2448,7 @@ static bool scan_command_token(
     !can_start_address(lexer) &&
     !is_blank(lexer->lookahead)
   ) {
-    return emit_missing_marker(
+    return emit_marker(
       lexer,
       valid_symbols,
       lexer->eof(lexer) ? INCOMPLETE_OMITTED_ADDRESS_MARKER
@@ -2837,13 +2471,7 @@ static bool scan_command_token(
   if (
     !at_command_boundary(lexer) &&
     !is_blank(lexer->lookahead) &&
-    valid_symbols[OMITTED_FILE_SEPARATOR_MARKER] &&
-    emit_missing_marker(
-      lexer,
-      valid_symbols,
-      OMITTED_FILE_SEPARATOR_MARKER,
-      symbol
-    )
+    emit_marker(lexer, valid_symbols, OMITTED_FILE_SEPARATOR_MARKER, symbol)
   ) {
     return true;
   }
@@ -2862,7 +2490,7 @@ static bool scan_command_token(
       index++
     ) {
       if (
-        emit_missing_marker(
+        emit_marker(
           lexer,
           valid_symbols,
           boundary_markers[index][variant],
@@ -2875,7 +2503,7 @@ static bool scan_command_token(
   }
 
   if (
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       missing_text_introducer_symbol(lexer),
@@ -2885,19 +2513,17 @@ static bool scan_command_token(
     return true;
   }
 
-  if (valid_symbols[MISSING_CLOSING_BRACE_MARKER] && lexer->eof(lexer)) {
-    return emit_missing_marker(
-      lexer,
-      valid_symbols,
-      MISSING_CLOSING_BRACE_MARKER,
-      symbol
-    );
+  if (
+    lexer->eof(lexer) &&
+    emit_marker(lexer, valid_symbols, MISSING_CLOSING_BRACE_MARKER, symbol)
+  ) {
+    return true;
   }
 
   if (
     !at_command_boundary(lexer) &&
     !is_blank(lexer->lookahead) &&
-    emit_missing_marker(
+    emit_marker(
       lexer,
       valid_symbols,
       MISSING_SEPARATOR_AFTER_UNMATCHED_BRACE_MARKER,
@@ -2907,38 +2533,10 @@ static bool scan_command_token(
     return true;
   }
 
-  if (lexer->lookahead == '}') {
-    if (
-      emit_missing_marker(
-        lexer,
-        valid_symbols,
-        MISSING_SEPARATOR_BEFORE_UNMATCHED_BRACE_MARKER,
-        symbol
-      )
-    ) {
-      return true;
-    }
-    if (
-      emit_missing_marker(
-        lexer,
-        valid_symbols,
-        MISSING_COMMAND_SEPARATOR_MARKER,
-        symbol
-      )
-    ) {
-      return true;
-    }
-  } else if (lexer->eof(lexer)) {
-    if (
-      emit_missing_marker(
-        lexer,
-        valid_symbols,
-        INCOMPLETE_COMMAND_SEPARATOR_MARKER,
-        symbol
-      )
-    ) {
-      return true;
-    }
+  const TSSymbol separator_marker =
+    missing_command_separator_marker(lexer, valid_symbols);
+  if (separator_marker != ERROR_SENTINEL) {
+    return emit_marker(lexer, valid_symbols, separator_marker, symbol);
   }
 
   const TSSymbol missing_opening_delimiter = lexer->eof(lexer)
@@ -2946,7 +2544,7 @@ static bool scan_command_token(
     : NONCONFORMING_MISSING_OPENING_DELIMITER_MARKER;
   if (
     delimiter_is_missing(lexer) &&
-    emit_missing_marker(lexer, valid_symbols, missing_opening_delimiter, symbol)
+    emit_marker(lexer, valid_symbols, missing_opening_delimiter, symbol)
   ) {
     return true;
   }
@@ -2982,9 +2580,12 @@ static bool sed_scanner_scan_impl(
     (!is_regex_mode(state->mode) ||
       state->regex_state == REGEX_OUTSIDE_BRACKET);
   if (delimiter_is_active) {
-    if (state->regex_group_depth > 0 && valid_symbols[REGEX_UNCLOSED_GROUP]) {
+    if (
+      state->regex_group_depth >
+      0 &&
+      emit_marker(lexer, valid_symbols, REGEX_UNCLOSED_GROUP, symbol)
+    ) {
       state->regex_group_depth--;
-      *symbol = REGEX_UNCLOSED_GROUP;
       return true;
     }
     return scan_active_mode_delimiter(lexer, state, valid_symbols, symbol);
@@ -2995,10 +2596,9 @@ static bool sed_scanner_scan_impl(
   case MODE_SUBSTITUTE_PATTERN:
     return scan_regex_token(lexer, state, valid_symbols, symbol);
   case MODE_SUBSTITUTE_REPLACEMENT:
-    return scan_replacement_token(lexer, state, valid_symbols, symbol);
   case MODE_TRANSLATE_SOURCE:
   case MODE_TRANSLATE_DESTINATION:
-    return scan_translate_token(lexer, state, valid_symbols, symbol);
+    return scan_operand_token(lexer, state, valid_symbols, symbol);
   case MODE_TEXT:
     return false;
   case MODE_NONE:
@@ -3010,17 +2610,10 @@ static bool sed_scanner_scan_impl(
 
 static void
 update_regex_position_after_symbol(ScannerState *state, TSSymbol symbol) {
-#if !SED_REGEX_EXTENDED
-  if (
-    symbol ==
-    BRE_VERTICAL_LINE_ESCAPE_MARKER ||
-    symbol ==
-    BRE_QUESTION_MARK_ESCAPE_MARKER ||
-    symbol == BRE_PLUS_ESCAPE_MARKER
-  ) {
+  if (!is_regex_mode(state->mode)) {
     return;
   }
-#endif
+
   if (
     symbol ==
     REGEX_LEADING_DUPLICATION_MARKER ||
@@ -3036,24 +2629,20 @@ update_regex_position_after_symbol(ScannerState *state, TSSymbol symbol) {
   }
 
   if (symbol == REGEX_GROUP_OPEN) {
-    if (state->regex_group_depth < UINT16_MAX) {
-      state->regex_group_depth++;
-    }
-    set_regex_position(state, true, REGEX_DUPLICATION_NONE, false, false);
+    state->regex_group_depth++;
+    state->regex_position = REGEX_AT_BRANCH_START;
     return;
   }
 
   if (symbol == REGEX_GROUP_CLOSE) {
-    if (state->regex_group_depth > 0) {
-      state->regex_group_depth--;
-    }
-    set_regex_position(state, false, REGEX_DUPLICATION_NONE, false, false);
+    state->regex_group_depth--;
+    state->regex_position = REGEX_AFTER_ATOM;
     return;
   }
 
 #if SED_REGEX_EXTENDED
   if (symbol == REGEX_ALTERNATION_OPERATOR) {
-    set_regex_position(state, true, REGEX_DUPLICATION_NONE, true, false);
+    state->regex_position = REGEX_AFTER_ALTERNATION;
     return;
   }
 #endif
@@ -3067,7 +2656,11 @@ update_regex_position_after_symbol(ScannerState *state, TSSymbol symbol) {
     symbol == REGEX_BRE_SUBEXPRESSION_DOLLAR;
 #endif
   if (is_anchor) {
-    set_regex_position(state, true, REGEX_DUPLICATION_NONE, false, true);
+#if SED_REGEX_EXTENDED
+    state->regex_position = REGEX_AT_BRANCH_START;
+#else
+    state->regex_position = REGEX_AFTER_ANCHOR;
+#endif
     return;
   }
 
@@ -3083,30 +2676,18 @@ update_regex_position_after_symbol(ScannerState *state, TSSymbol symbol) {
     symbol == REGEX_ZERO_OR_ONE;
 #endif
   if (is_duplication) {
-    set_regex_position(
-      state,
-      false,
-      REGEX_AFTER_DUPLICATION_SYMBOL,
-      false,
-      false
-    );
+    state->regex_position = REGEX_AFTER_DUPLICATION_SYMBOL;
     return;
   }
 
 #if SED_REGEX_EXTENDED
   if (symbol == REGEX_REPETITION_MODIFIER) {
-    set_regex_position(
-      state,
-      false,
-      REGEX_AFTER_REPETITION_MODIFIER,
-      false,
-      false
-    );
+    state->regex_position = REGEX_AFTER_REPETITION_MODIFIER;
     return;
   }
 #endif
 
-  set_regex_position(state, false, REGEX_DUPLICATION_NONE, false, false);
+  state->regex_position = REGEX_AFTER_ATOM;
 }
 
 static bool