tree-sitter-sed 0.18.0 → 0.20.0

package/common/grammar.js

@@ -1,77 +1,3 @@
-import {
-  defineIssueRules,
-  issueField,
-  issueNode,
-  namedExternal,
-} from "./dsl.js";
-import regularExpressionRules from "./regex.js";
-
-function missingAtEndOrBoundary($, reason) {
-  return choice(
-    issueField($, reason),
-    issueField($, `nonconforming_${reason}`),
-  );
-}
-
-function blankSeparatedFileOperand($, name, operand) {
-  return seq(
-    $._blanks,
-    choice(operand, missingAtEndOrBoundary($, `missing_${name}`)),
-  );
-}
-
-function fileOperandForms($, name, operand) {
-  return [
-    blankSeparatedFileOperand($, name, operand),
-    seq(issueField($, "omitted_file_separator"), operand),
-    missingAtEndOrBoundary($, `missing_${name}`),
-  ];
-}
-
-function sourcePiece($, external, leaf) {
-  return choice(
-    namedExternal($, external, leaf),
-    issueField($, "nul_character"),
-    issueField($, "invalid_encoding"),
-  );
-}
-
-function sourcePieces($, leaf, external) {
-  return prec.right(repeat1(sourcePiece($, external, leaf)));
-}
-
-function lineOperand($, first, rest) {
-  return prec.right(
-    seq(
-      sourcePiece($, first, "file_literal"),
-      repeat(sourcePiece($, rest, "file_literal")),
-    ),
-  );
-}
-
-function operandAtoms($, literal, ...atoms) {
-  return repeat1(
-    choice(
-      literal,
-      seq($._escape_prefix, issueField($, "invalid_encoding")),
-      issueField($, "nul_character"),
-      issueField($, "invalid_encoding"),
-      ...atoms,
-    ),
-  );
-}
-
-function missingCommandSeparator($) {
-  return choice(
-    issueNode($, "missing_command_separator"),
-    issueNode($, "incomplete_missing_command_separator"),
-  );
-}
-
-function functionVerb($, spelling) {
-  return field("verb", alias(spelling, $.function_verb));
-}
-
 const functionDefinitions = [
   { rule: "block_function", spelling: "{", form: "block" },
   {
@@ -120,6 +46,12 @@ const functionDefinitions = [
     lineTerminated: true,
   },
   { rule: "substitute_function", spelling: "s", form: "substitute" },
+  {
+    rule: "_write_substitute_function",
+    spelling: "s",
+    form: "substitute",
+    writeTerminated: true,
+  },
   {
     rule: "test_function",
     spelling: "t",
@@ -155,44 +87,185 @@ const functionDefinitions = [
   },
 ];
 
-// Matching known verbs here creates GLR branches that compete with valid
-// commands.
 const unknownFunctionCharacter = new RegExp(
   `[^ \\t0-9$\\/\\\\!;}\\n${functionDefinitions
     .map(({ spelling }) => spelling)
     .join("")}]`,
 );
 
-// String-only flag rules share verb tokens and would wrap anonymous leaves.
-const letterSubstitutionFlags = {
-  global_flag: "g",
-  case_insensitive_flag: "i",
-  print_flag: "p",
-};
+function defineIssueRules(definitions) {
+  const rules = {};
+  for (const { reason, id = reason, outcome, rule } of definitions) {
+    rules[`_${id}_reason`] = rule;
+    rules[`_${id}_outcome`] = ($) => alias($[`_${id}_reason`], $[reason]);
+    rules[`_${id}_issue`] = ($) => alias($[`_${id}_outcome`], $[outcome]);
+  }
+  return rules;
+}
+
+function issueField($, id) {
+  return field("issue", alias($[`_${id}_issue`], $.syntax_issue));
+}
+
+function missingAtEndOrBoundary($, reason) {
+  return choice(
+    issueField($, reason),
+    issueField($, `nonconforming_${reason}`),
+  );
+}
+
+function blankSeparatedFileOperand($, name, operand) {
+  return seq(
+    $._blanks,
+    choice(operand, missingAtEndOrBoundary($, `missing_${name}`)),
+  );
+}
 
-function nonWriteSubstitutionFlags($) {
+function fileOperandForms($, name, operand) {
   return [
-    $.occurrence_flag,
-    ...Object.entries(letterSubstitutionFlags).map(([rule, spelling]) =>
-      alias(spelling, $[rule]),
-    ),
+    blankSeparatedFileOperand($, name, operand),
+    seq(issueField($, "omitted_file_separator"), operand),
+    missingAtEndOrBoundary($, `missing_${name}`),
   ];
 }
 
-function postWriteSubstitutionFlagChoice($) {
+function sourcePiece($, external, leaf) {
+  return choice(
+    alias(external, $[leaf]),
+    issueField($, "nul_character"),
+    issueField($, "invalid_encoding"),
+  );
+}
+
+function lineOperand($, first, rest) {
+  return prec.right(
+    seq(
+      sourcePiece($, first, "file_literal"),
+      repeat(sourcePiece($, rest, "file_literal")),
+    ),
+  );
+}
+
+function operandAtoms($, literal, ...atoms) {
+  return repeat1(
+    choice(
+      literal,
+      seq($._escape_prefix, issueField($, "invalid_encoding")),
+      issueField($, "nul_character"),
+      issueField($, "invalid_encoding"),
+      ...atoms,
+    ),
+  );
+}
+
+function missingCommandSeparator($) {
   return choice(
-    ...nonWriteSubstitutionFlags($),
-    alias("w", $.substitution_flag),
+    issueField($, "missing_command_separator"),
+    issueField($, "incomplete_missing_command_separator"),
   );
 }
 
+function functionVerb($, spelling) {
+  return field("verb", alias(spelling, $.function_verb));
+}
+
+const exclusiveSubstitutionFlags = [
+  {
+    bit: 1,
+    flag: ($) => alias("g", $.global_flag),
+    conflict: "conflicting_global_flag",
+  },
+  {
+    bit: 2,
+    flag: ($) => $.occurrence_flag,
+    conflict: "conflicting_occurrence_flag",
+  },
+];
+
+function substitutionFlagRules() {
+  const rules = {};
+  for (const ending of ["plain", "write", "postwrite"]) {
+    for (const seen of [0, 1, 2, 3]) {
+      rules[`_flags_${ending}_${seen}`] = ($) => {
+        const steady = [
+          alias("i", $.case_insensitive_flag),
+          alias("p", $.print_flag),
+          ...(ending === "postwrite"
+            ? [
+                choice(
+                  alias("w", $.substitution_flag),
+                  issueField($, "nonfinal_write_flag"),
+                ),
+              ]
+            : [
+                issueField($, "invalid_substitution_flag"),
+                issueField($, "invalid_encoding"),
+              ]),
+        ];
+        const transitions = [];
+        for (const { bit, flag, conflict } of exclusiveSubstitutionFlags) {
+          const symbol = seen & ~bit ? issueField($, conflict) : flag($);
+          if (seen & bit) {
+            steady.push(symbol);
+          } else {
+            const tail = $[`_flags_${ending}_${seen | bit}`];
+            transitions.push(
+              seq(symbol, ending === "write" ? tail : optional(tail)),
+            );
+          }
+        }
+        if (ending === "write") {
+          return prec.right(
+            seq(
+              repeat(choice(...steady)),
+              choice(
+                alias($[`_write_flag_${seen}`], $.write_flag),
+                ...transitions,
+              ),
+            ),
+          );
+        }
+        return prec.right(
+          transitions.length === 0
+            ? repeat1(choice(...steady))
+            : choice(
+                repeat1(choice(...steady)),
+                seq(repeat(choice(...steady)), choice(...transitions)),
+              ),
+        );
+      };
+    }
+  }
+  for (const seen of [0, 1, 2, 3]) {
+    rules[`_write_flag_${seen}`] = ($) => {
+      const wfile = field("wfile", alias($._substitution_wfile, $.wfile));
+      return choice(
+        seq(
+          field("verb", alias("w", $.substitution_flag)),
+          choice(
+            ...fileOperandForms($, "wfile", wfile),
+            seq(issueField($, "incomplete_omitted_file_separator"), wfile),
+          ),
+        ),
+        seq(
+          issueField($, "nonfinal_write_flag"),
+          $[`_flags_postwrite_${seen}`],
+          blankSeparatedFileOperand($, "wfile", wfile),
+        ),
+      );
+    };
+  }
+  return rules;
+}
+
 function delimiter($, name) {
-  return namedExternal($, $[`_${name}`], "delimiter");
+  return alias($[`_${name}`], $.delimiter);
 }
 
 function missingOpeningDelimiter($) {
   return choice(
     issueField($, "invalid_delimiter"),
+    issueField($, "invalid_encoding"),
     issueField($, "missing_opening_delimiter"),
     issueField($, "nonconforming_missing_opening_delimiter"),
   );
@@ -217,6 +290,23 @@ function semicolonSeparator($) {
   return alias(";", $.command_separator);
 }
 
+function writeCommandUnit($, block = false) {
+  return seq(
+    editingCommand($, "write_terminated"),
+    choice(
+      newlineSeparator($),
+      alias(
+        block ? $._write_block_terminal_separator : $._write_terminal_separator,
+        $.command_separator,
+      ),
+      issueField($, "undefined_write_command_separator"),
+      ...(block
+        ? []
+        : [issueField($, "missing_separator_before_unmatched_brace")]),
+    ),
+  );
+}
+
 function commandListRules() {
   return {
     script: ($) => optional(alias($._script_command_list, $.command_list)),
@@ -249,17 +339,12 @@ function commandListRules() {
       seq(
         field(
           "suppression",
-          namedExternal(
-            $,
-            $._default_output_suppression,
-            "default_output_suppression",
-          ),
+          alias($._default_output_suppression, $.default_output_suppression),
         ),
         repeat(sourcePiece($, $._comment_text, "comment_text")),
       ),
 
-    // Explicit recursion makes cursor traversal quadratic; repeat keeps lists
-    // balanced.
+    // Explicit recursion makes cursor traversal quadratic.
     _command_list: ($) =>
       choice(
         seq(
@@ -272,12 +357,13 @@ function commandListRules() {
 
     _command_unit: ($) =>
       choice(
+        writeCommandUnit($),
         seq(
           $._separable_command_item,
           choice(
             semicolonSeparator($),
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
           ),
         ),
         seq(
@@ -285,15 +371,15 @@ function commandListRules() {
           choice(
             semicolonSeparator($),
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
-            issueNode($, "missing_separator_after_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_after_unmatched_brace"),
           ),
         ),
         seq(
           editingCommand($, "line_terminated"),
           choice(
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
           ),
         ),
         editingCommand($, "recovered_line_terminated"),
@@ -304,12 +390,13 @@ function commandListRules() {
         $._separable_command_item,
         $._unmatched_closing_brace_item,
         editingCommand($, "line_terminated"),
+        editingCommand($, "write_terminated"),
       ),
 
     _unmatched_closing_brace_item: ($) =>
       seq(
         optional($._brace_leading_blanks),
-        issueNode($, "unmatched_closing_brace"),
+        issueField($, "unmatched_closing_brace"),
         optional($._blanks),
       ),
 
@@ -323,15 +410,13 @@ function commandListRules() {
     _block_commands: ($) =>
       choice(
         repeat1($._block_unit),
-        seq(
-          repeat($._block_unit),
-          optional($._block_item),
-          missingCommandSeparator($),
-        ),
+        seq(repeat($._block_unit), $._block_item, missingCommandSeparator($)),
+        missingCommandSeparator($),
       ),
 
     _block_unit: ($) =>
       choice(
+        writeCommandUnit($, true),
         seq(
           $._separable_command_item,
           choice(semicolonSeparator($), newlineSeparator($)),
@@ -341,7 +426,11 @@ function commandListRules() {
       ),
 
     _block_item: ($) =>
-      choice($._separable_command_item, editingCommand($, "line_terminated")),
+      choice(
+        $._separable_command_item,
+        editingCommand($, "line_terminated"),
+        editingCommand($, "write_terminated"),
+      ),
 
     empty_command: ($) => seq(optional($._blanks), $._empty_command_marker),
 
@@ -356,8 +445,13 @@ function omittedAddress($) {
   );
 }
 
+const regularExpressionRules = {
+  bre: { expression: "basic_reg_exp", duplication: "bre_dupl_symbol" },
+  ere: { expression: "extended_reg_exp", duplication: "ere_dupl_symbol" },
+};
+
 function addressRules(mode) {
-  const expression = mode === "bre" ? "basic_reg_exp" : "extended_reg_exp";
+  const { expression } = regularExpressionRules[mode];
 
   function addressChoice($) {
     return choice(
@@ -511,14 +605,7 @@ function delimitedFunction($, spelling, name, first, middleReason, rest) {
 }
 
 function operandRules(mode) {
-  const expression = mode === "bre" ? "basic_reg_exp" : "extended_reg_exp";
-
-  function substitutionFlagChoice($) {
-    return choice(
-      ...nonWriteSubstitutionFlags($),
-      issueField($, "invalid_substitution_flag"),
-    );
-  }
+  const { expression } = regularExpressionRules[mode];
 
   return {
     substitute_function: ($) =>
@@ -534,10 +621,7 @@ function operandRules(mode) {
             seq(
               field("closing", delimiter($, "substitute_end")),
               optional(
-                field(
-                  "flags",
-                  alias($._substitution_flags, $.substitution_flags),
-                ),
+                field("flags", alias($._flags_plain_0, $.substitution_flags)),
               ),
             ),
             unterminatedDelimiter($, "replacement"),
@@ -571,30 +655,20 @@ function operandRules(mode) {
 
     escaped_newline: ($) => $._replacement_escaped_newline,
 
-    _substitution_flags: ($) =>
-      prec.right(
-        choice(
-          repeat1(substitutionFlagChoice($)),
-          seq(repeat(substitutionFlagChoice($)), $.write_flag),
-        ),
+    _write_substitute_function: ($) =>
+      seq(
+        functionVerb($, "s"),
+        field("opening", delimiter($, "substitute_start")),
+        optional(field("expression", $[expression])),
+        field("middle", delimiter($, "substitute_middle")),
+        optional(field("replacement", $.replacement)),
+        field("closing", delimiter($, "substitute_end")),
+        field("flags", alias($._flags_write_0, $.substitution_flags)),
       ),
 
-    occurrence_flag: () => /[0-9]+/,
+    ...substitutionFlagRules(),
 
-    write_flag: ($) => {
-      const wfile = field("wfile", alias($._substitution_wfile, $.wfile));
-      return seq(
-        field("verb", alias("w", $.substitution_flag)),
-        choice(
-          seq(
-            $._flag_after_write_marker,
-            repeat1(postWriteSubstitutionFlagChoice($)),
-            blankSeparatedFileOperand($, "wfile", wfile),
-          ),
-          ...fileOperandForms($, "wfile", wfile),
-        ),
-      );
-    },
+    occurrence_flag: () => /[0-9]+/,
 
     translate_function: ($) =>
       delimitedFunction(
@@ -673,16 +747,31 @@ function functionRules() {
         $._substitution_wfile_continuation,
       ),
 
-    label: ($) => sourcePieces($, "label_literal", $._line_word),
+    label: ($) =>
+      choice(
+        seq($._label_start, $._label_body),
+        issueField($, "nonportable_label_length"),
+      ),
+
+    _label_body: ($) =>
+      prec.right(
+        repeat1(
+          choice(
+            sourcePiece($, $._label_literal, "label_literal"),
+            issueField($, "nonportable_label_character"),
+          ),
+        ),
+      ),
 
-    comment: ($) => sourcePieces($, "comment_text", $._comment_text),
+    comment: ($) =>
+      prec.right(repeat1(sourcePiece($, $._comment_text, "comment_text"))),
 
     comment_function: ($) =>
       prec.right(
         seq(functionVerb($, "#"), optional(field("comment", $.comment))),
       ),
 
-    closing_brace: ($) => $._right_brace,
+    closing_brace: () => token("}"),
   };
 
   function fileForm(form) {
@@ -715,7 +804,7 @@ function functionRules() {
           seq(
             field(
               "separator",
-              namedExternal($, $._argument_separator, "argument_separator"),
+              alias($._argument_separator, $.argument_separator),
             ),
             optional(field("label", $.label)),
           ),
@@ -747,10 +836,22 @@ function functionRules() {
   return rules;
 }
 
+function commandTail($) {
+  return seq(
+    repeat(issueField($, "invalid_encoding")),
+    optional(
+      choice(
+        issueField($, "unexpected_command_text"),
+        issueField($, "incomplete_command_text"),
+      ),
+    ),
+  );
+}
+
 function unknownFunction($, id) {
   return seq(
-    issueField($, id),
-    optional(issueField($, "unexpected_command_text")),
+    choice(issueField($, id), issueField($, "invalid_encoding")),
+    commandTail($),
   );
 }
 
@@ -761,18 +862,24 @@ function editingCommandRules() {
     2: ($) => $.address_clause,
   };
 
-  // Keep address, issue, and function rules separate by address maximum so
-  // GLR paths cannot merge before the function verb.
+  // Separate address limits to prevent GLR merging before the verb.
   const wrappers = [];
   for (const [kind, isLineTerminated] of [
     ["chainable", false],
     ["line_terminated", true],
+    ["write_terminated", false],
   ]) {
     for (const maximum of [0, 1, 2]) {
       const names = functionDefinitions
         .filter(
-          ({ lineTerminated = false, maxAddresses = 2 }) =>
-            lineTerminated === isLineTerminated && maxAddresses === maximum,
+          ({
+            lineTerminated = false,
+            writeTerminated = false,
+            maxAddresses = 2,
+          }) =>
+            writeTerminated === (kind === "write_terminated") &&
+            lineTerminated === isLineTerminated &&
+            maxAddresses === maximum,
         )
         .map(({ rule }) => rule);
       if (names.length > 0) {
@@ -815,16 +922,13 @@ function editingCommandRules() {
 
   const rules = {
     _chainable_editing_command: ($) =>
-      seq(
-        addressedForms($, "chainable"),
-        optional(issueField($, "unexpected_command_text")),
-      ),
+      seq(addressedForms($, "chainable"), commandTail($)),
+
+    _write_terminated_editing_command: ($) =>
+      seq(addressedForms($, "write_terminated"), commandTail($)),
 
     _line_terminated_editing_command: ($) =>
-      seq(
-        addressedForms($, "line_terminated"),
-        optional(issueField($, "unexpected_command_text")),
-      ),
+      seq(addressedForms($, "line_terminated"), commandTail($)),
 
     _recovered_line_terminated_editing_command: ($) =>
       seq(
@@ -870,7 +974,14 @@ function editingCommandRules() {
   };
 
   for (const { name, names } of wrappers) {
-    rules[name] = ($) => choice(...names.map((name) => $[name]));
+    rules[name] = ($) =>
+      choice(
+        ...names.map((name) =>
+          name === "_write_substitute_function"
+            ? alias($[name], $.substitute_function)
+            : $[name],
+        ),
+      );
   }
 
   return rules;
@@ -886,38 +997,460 @@ function sedRules(mode) {
   };
 }
 
-const missingCommandDefinitions = [
-  { reason: "missing_function", atBoundary: true },
-  { reason: "missing_label", atBoundary: true },
-  { reason: "missing_rfile", atBoundary: true },
-  { reason: "missing_wfile", atBoundary: true },
-  { reason: "missing_text_introducer", atBoundary: true },
-  {
-    reason: "incomplete_text_introducer",
-    rule: ($) => $._text_incomplete_introducer,
-  },
-  { reason: "missing_text" },
-  { reason: "missing_closing_brace" },
-  { reason: "missing_opening_delimiter", atBoundary: true },
-];
+const nonportableRangeClasses = ["character_class", "equivalence_class"];
 
-const boundaryMissingReasons = missingCommandDefinitions
-  .filter(({ atBoundary }) => atBoundary)
-  .map(({ reason }) => reason);
+function intervalExpression($, opening, closing) {
+  const piece = (name) =>
+    choice(
+      field(name, $.duplication_count),
+      field(name, alias($._regex_interval_escaped_count, $.escaped_delimiter)),
+      issueField($, "invalid_interval_character"),
+      ...(opening === "{"
+        ? [issueField($, "incomplete_regular_expression_escape")]
+        : []),
+      issueField($, "invalid_regular_expression_character"),
+      issueField($, "invalid_encoding"),
+      seq(
+        $._escape_prefix,
+        choice(
+          issueField($, "escaped_invalid_regular_expression_character"),
+          issueField($, "invalid_encoding"),
+        ),
+      ),
+    );
+  return seq(
+    alias($._regex_interval_open, opening),
+    choice(
+      repeat1(piece("minimum")),
+      issueField($, "missing_interval_minimum"),
+      issueField($, "incomplete_interval_minimum"),
+    ),
+    optional(
+      seq(
+        choice(
+          alias($._regex_interval_separator, ","),
+          alias($._regex_interval_escaped_separator, $.escaped_delimiter),
+        ),
+        repeat(
+          choice(
+            piece("maximum"),
+            issueField($, "unexpected_interval_separator"),
+          ),
+        ),
+      ),
+    ),
+    choice(
+      alias($._regex_interval_close, closing),
+      issueField($, "missing_interval_close"),
+      issueField($, "incomplete_interval"),
+      ...(opening === "\\{"
+        ? [
+            issueField($, "invalid_interval_close"),
+            issueField($, "incomplete_interval_close"),
+          ]
+        : []),
+    ),
+  );
+}
 
-function missingMarkerNames(mode) {
-  return [
-    "omitted_address",
-    "incomplete_omitted_address",
-    "omitted_first_address",
-    "empty_subexpression",
-    "missing_subexpression",
-    ...(mode === "ere" ? ["empty_alternative"] : []),
-    "missing_function",
-    "missing_label",
+function compoundBracketExpression(
+  $,
+  openingExternal,
+  marker,
+  contentField,
+  content,
+  closingExternal,
+  ...payloadIssues
+) {
+  const closingIssues = [
+    issueField($, "missing_bracket_term_close"),
+    issueField($, "incomplete_bracket_term"),
+  ];
+  const closing = seq(
+    alias(closingExternal, marker),
+    choice("]", ...closingIssues),
+  );
+  const payload = repeat1(
+    choice(
+      field(contentField, content),
+      issueField($, "invalid_regular_expression_character"),
+      issueField($, "invalid_encoding"),
+      ...payloadIssues.map((reason) => issueField($, reason)),
+    ),
+  );
+  return seq(
+    alias(openingExternal, "["),
+    marker,
+    choice(
+      payload,
+      issueField($, "missing_bracket_term_payload"),
+      issueField($, "incomplete_bracket_term_payload"),
+    ),
+    choice(closing, ...closingIssues),
+  );
+}
+
+function bracketListBody($, list) {
+  return choice(
+    list,
+    issueField($, "missing_bracket_list"),
+    issueField($, "incomplete_missing_bracket_list"),
+  );
+}
+
+function subexpressionClose($, closing) {
+  return choice(
+    field("closing", alias($._regex_group_close, closing)),
+    issueField($, "unclosed_subexpression"),
+    issueField($, "incomplete_unclosed_subexpression"),
+  );
+}
+
+function bracketExpression($, ambiguous) {
+  return seq(
+    alias($._regex_bracket_open, "["),
+    bracketListBody($, choice($.matching_list, $.nonmatching_list)),
+    ...(ambiguous ? [$._ambiguous_bracket_expression_marker] : []),
+    choice(
+      alias($._regex_bracket_close, "]"),
+      issueField($, "unclosed_bracket_expression"),
+      issueField($, "incomplete_unclosed_bracket_expression"),
+    ),
+  );
+}
+
+function rangeOperator($) {
+  return alias($._regex_bracket_hyphen, "-");
+}
+
+function nonportableRangeRules() {
+  const rules = {};
+  for (const kind of nonportableRangeClasses) {
+    rules[`_${kind}_start_range`] = ($) =>
+      seq(issueField($, `${kind}_range_start`), rangeOperator($));
+  }
+  for (const kind of nonportableRangeClasses) {
+    rules[`_${kind}_end_range`] = ($) => issueField($, `${kind}_range_end`);
+  }
+  return rules;
+}
+
+function bracketRules() {
+  return {
+    bracket_expression: ($) => bracketExpression($, false),
+
+    _ambiguous_bracket_expression: ($) => bracketExpression($, true),
+
+    _bracket_expression: ($) =>
+      choice(
+        $.bracket_expression,
+        issueField($, "ambiguous_bracket_expression"),
+      ),
+
+    matching_list: ($) => $.bracket_list,
+
+    nonmatching_list: ($) =>
+      seq(
+        alias($._regex_bracket_negation, "^"),
+        bracketListBody($, $.bracket_list),
+      ),
+
+    bracket_list: ($) =>
+      seq(
+        $.follow_list,
+        optional(alias($._regex_bracket_trailing_hyphen, "-")),
+      ),
+
+    follow_list: ($) => repeat1($.expression_term),
+
+    expression_term: ($) =>
+      choice(
+        $.single_expression,
+        $.range_expression,
+        issueField($, "shared_range_endpoint"),
+      ),
+
+    single_expression: ($) =>
+      choice($.end_range, $.character_class, $.equivalence_class),
+
+    range_expression: ($) =>
+      seq(
+        choice(
+          $.start_range,
+          ...nonportableRangeClasses.map((kind) =>
+            alias($[`_${kind}_start_range`], $.start_range),
+          ),
+        ),
+        choice(
+          $.end_range,
+          ...nonportableRangeClasses.map((kind) =>
+            alias($[`_${kind}_end_range`], $.end_range),
+          ),
+          alias($._regex_bracket_range_end_hyphen, "-"),
+        ),
+      ),
+
+    ...nonportableRangeRules(),
+
+    start_range: ($) => seq($.end_range, rangeOperator($)),
+
+    end_range: ($) =>
+      choice(
+        alias($._regex_bracket_literal, $.collating_element_single),
+        $.collating_symbol,
+        issueField($, "invalid_regular_expression_character"),
+        issueField($, "invalid_encoding"),
+      ),
+
+    collating_symbol: ($) =>
+      compoundBracketExpression(
+        $,
+        $._regex_open_dot,
+        ".",
+        "element",
+        choice(
+          alias($._regex_coll_elem_single, $.collating_element_single),
+          alias($._regex_coll_elem_multi, $.collating_element_multi),
+          alias($._regex_meta_char, $.meta_character),
+        ),
+        $._regex_dot_close,
+      ),
+
+    equivalence_class: ($) =>
+      compoundBracketExpression(
+        $,
+        $._regex_open_equal,
+        "=",
+        "element",
+        choice(
+          alias($._regex_coll_elem_single, $.collating_element_single),
+          alias($._regex_coll_elem_multi, $.collating_element_multi),
+        ),
+        $._regex_equal_close,
+        "equivalence_class_meta_character",
+        "incomplete_equivalence_class_meta_character",
+      ),
+
+    character_class: ($) =>
+      compoundBracketExpression(
+        $,
+        $._regex_open_colon,
+        ":",
+        "name",
+        alias($._regex_class_name, $.class_name),
+        $._regex_colon_close,
+        "invalid_character_class_name",
+      ),
+  };
+}
+
+function regularExpressionEscape($) {
+  return choice(
+    $.quoted_character,
+    seq(
+      $._escape_prefix,
+      choice(
+        issueField($, "escaped_invalid_regular_expression_character"),
+        issueField($, "invalid_encoding"),
+      ),
+    ),
+    $.escaped_delimiter,
+    issueField($, "ordinary_character_escape"),
+    issueField($, "incomplete_regular_expression_escape"),
+    issueField($, "forbidden_regular_expression_newline"),
+  );
+}
+
+function oneCharOrCollElem($, ...additional) {
+  return choice(
+    issueField($, "invalid_regular_expression_character"),
+    issueField($, "invalid_encoding"),
+    $.ordinary_character,
+    regularExpressionEscape($),
+    $.sed_newline_escape,
+    alias($._regex_period, "."),
+    $._bracket_expression,
+    issueField($, "special_delimiter_escape"),
+    ...additional,
+  );
+}
+
+function commonRegularExpressionRules() {
+  return {
+    duplication_count: ($) => $._regex_dup_count,
+
+    ordinary_character: ($) => $._regex_literal,
+
+    quoted_character: ($) => $._regex_quoted_escape,
+
+    escaped_delimiter: ($) => $._regex_escaped_delimiter,
+
+    sed_newline_escape: ($) => $._regex_newline_escape,
+
+    ...bracketRules(),
+  };
+}
+
+function breRules() {
+  return {
+    ...commonRegularExpressionRules(),
+    basic_reg_exp: ($) => $.bre_branch,
+
+    bre_branch: ($) => repeat1($.bre_expression),
+
+    bre_expression: ($) =>
+      prec.right(
+        choice(
+          seq(
+            alias($._regex_beginning_anchor, "^"),
+            optional($.simple_bre),
+            optional(alias($._regex_end_anchor, "$")),
+          ),
+          seq($.simple_bre, optional(alias($._regex_end_anchor, "$"))),
+          alias($._regex_end_anchor, "$"),
+        ),
+      ),
+
+    simple_bre: ($) =>
+      seq(
+        choice(
+          seq($.nondupl_bre, optional($.bre_dupl_symbol)),
+          issueField($, "leading_duplication_symbol"),
+        ),
+        repeat(issueField($, "adjacent_duplication_symbol")),
+      ),
+
+    nondupl_bre: ($) =>
+      choice(
+        $.one_char_or_coll_elem_bre,
+        seq(
+          field("opening", alias($._regex_group_open, "\\(")),
+          optional(field("expression", $.basic_reg_exp)),
+          subexpressionClose($, "\\)"),
+        ),
+        $.backreference,
+        issueField($, "unmatched_subexpression_close"),
+        issueField($, "unmatched_interval_close"),
+      ),
+
+    backreference: ($) => $._regex_backreference,
+
+    one_char_or_coll_elem_bre: ($) =>
+      oneCharOrCollElem(
+        $,
+        issueField($, "bre_vertical_line_escape"),
+        issueField($, "bre_question_mark_escape"),
+        issueField($, "bre_plus_escape"),
+        issueField($, "bre_subexpression_right_anchor"),
+        issueField($, "bre_subexpression_left_anchor"),
+      ),
+
+    bre_dupl_symbol: ($) =>
+      choice(alias($._regex_zero_or_more, "*"), $._bre_interval),
+
+    _bre_interval: ($) => intervalExpression($, "\\{", "\\}"),
+  };
+}
+
+function ereRules() {
+  return {
+    ...commonRegularExpressionRules(),
+    extended_reg_exp: ($) =>
+      choice(
+        $.ere_branch,
+        seq(
+          choice($.ere_branch, $._empty_ere_branch),
+          repeat1(
+            seq(
+              alias($._regex_alternation_operator, "|"),
+              choice($.ere_branch, $._empty_ere_branch),
+            ),
+          ),
+        ),
+      ),
+
+    _empty_ere_branch: ($) =>
+      choice(
+        issueField($, "empty_alternative"),
+        issueField($, "incomplete_alternative"),
+      ),
+
+    ere_branch: ($) => repeat1($.ere_expression),
+
+    ere_expression: ($) =>
+      prec.left(
+        1,
+        seq(
+          choice(
+            $.one_char_or_coll_elem_ere,
+            alias($._regex_beginning_anchor, "^"),
+            alias($._regex_end_anchor, "$"),
+            seq(
+              field("opening", alias($._regex_group_open, "(")),
+              optional(field("expression", $.extended_reg_exp)),
+              subexpressionClose($, ")"),
+            ),
+            issueField($, "leading_duplication_symbol"),
+          ),
+          repeat(
+            choice(
+              $.ere_dupl_symbol,
+              issueField($, "adjacent_duplication_symbol"),
+            ),
+          ),
+        ),
+      ),
+
+    one_char_or_coll_elem_ere: ($) => oneCharOrCollElem($),
+
+    ere_dupl_symbol: ($) =>
+      seq(
+        choice(
+          alias($._regex_zero_or_more, "*"),
+          alias($._regex_one_or_more, "+"),
+          alias($._regex_zero_or_one, "?"),
+          $._ere_interval,
+        ),
+        optional(field("modifier", $.repetition_modifier)),
+      ),
+
+    _ere_interval: ($) => intervalExpression($, "{", "}"),
+
+    repetition_modifier: ($) => $._regex_repetition_modifier,
+  };
+}
+
+const missingCommandDefinitions = [
+  { reason: "missing_function", atBoundary: true },
+  { reason: "missing_label", atBoundary: true },
+  { reason: "missing_rfile", atBoundary: true },
+  { reason: "missing_wfile", atBoundary: true },
+  { reason: "missing_text_introducer", atBoundary: true },
+  {
+    reason: "incomplete_text_introducer",
+    rule: ($) => $._text_incomplete_introducer,
+  },
+  { reason: "missing_text" },
+  { reason: "missing_closing_brace" },
+  { reason: "missing_opening_delimiter", atBoundary: true },
+];
+
+const boundaryMissingReasons = missingCommandDefinitions
+  .filter(({ atBoundary }) => atBoundary)
+  .map(({ reason }) => reason);
+
+function missingMarkerNames(mode) {
+  return [
+    "omitted_address",
+    "incomplete_omitted_address",
+    "omitted_first_address",
+    ...(mode === "ere" ? ["empty_alternative"] : []),
+    "missing_function",
+    "missing_label",
     "missing_rfile",
     "missing_wfile",
     "omitted_file_separator",
+    "incomplete_omitted_file_separator",
     "missing_text_introducer",
     "missing_text",
     "missing_command_separator",
@@ -927,7 +1460,6 @@ function missingMarkerNames(mode) {
     "missing_separator_before_unmatched_brace",
     "missing_separator_after_unmatched_brace",
     ...boundaryMissingReasons.map((reason) => `nonconforming_${reason}`),
-    "missing_subexpression_placeholder",
     "incomplete_bracket_list",
     "incomplete_bracket_expression",
     ...(mode === "ere" ? ["incomplete_alternative"] : []),
@@ -942,21 +1474,48 @@ function issueDefinitions(mode) {
 
   return [
     {
-      reason: "malformed_bracket_term",
+      reason: "nonportable_label_character",
+      outcome: "unspecified_syntax",
+      rule: ($) => alias($._nonportable_label_character, $.label_literal),
+    },
+    {
+      reason: "nonportable_label_length",
+      outcome: "unspecified_syntax",
+      rule: ($) =>
+        seq($._long_label_start, alias($._label_literal, $.label_literal)),
+    },
+    {
+      reason: "missing_bracket_term_close",
       outcome: "undefined_syntax",
-      rule: ($) => $._regex_malformed_bracket_term,
+      rule: ($) => $._regex_missing_bracket_term_close,
     },
     {
-      id: "invalid_character_class_name",
-      reason: "malformed_bracket_term",
+      reason: "invalid_character_class_name",
       outcome: "undefined_syntax",
       rule: ($) => $._regex_invalid_class_name,
     },
     {
       id: "equivalence_class_meta_character",
-      reason: "malformed_bracket_term",
+      reason: "invalid_equivalence_class_element",
+      outcome: "undefined_syntax",
+      rule: ($) => alias($._regex_meta_char, $.meta_character),
+    },
+    {
+      id: "incomplete_equivalence_class_meta_character",
+      reason: "invalid_equivalence_class_element",
+      outcome: "incomplete_syntax",
+      rule: ($) => alias($._regex_incomplete_meta_char, $.meta_character),
+    },
+    {
+      reason: "missing_bracket_term_payload",
       outcome: "undefined_syntax",
-      rule: ($) => namedExternal($, $._regex_meta_char, "meta_char"),
+      rule: ($) => $._regex_missing_bracket_term_payload,
+    },
+    {
+      id: "incomplete_bracket_term_payload",
+      reason: "missing_bracket_term_payload",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._regex_incomplete_bracket_term_payload,
     },
     {
       reason: "nul_character",
@@ -968,6 +1527,18 @@ function issueDefinitions(mode) {
       outcome: "invalid_syntax",
       rule: ($) => $._nul_character,
     },
+    {
+      id: "escaped_nul_character",
+      reason: "nul_character",
+      outcome: "nonconforming_syntax",
+      rule: ($) => $._single_nul_character,
+    },
+    {
+      id: "escaped_invalid_regular_expression_character",
+      reason: "invalid_regular_expression_character",
+      outcome: "invalid_syntax",
+      rule: ($) => $._single_nul_character,
+    },
     {
       reason: "invalid_encoding",
       outcome: "invalid_syntax",
@@ -986,8 +1557,7 @@ function issueDefinitions(mode) {
     {
       reason: "shared_range_endpoint",
       outcome: "undefined_syntax",
-      rule: ($) =>
-        namedExternal($, $._regex_shared_range_endpoint, "range_operator"),
+      rule: ($) => alias($._regex_shared_range_endpoint, "-"),
     },
     {
       reason: "omitted_address",
@@ -1017,11 +1587,6 @@ function issueDefinitions(mode) {
       outcome: "undefined_syntax",
       rule: ($) => $._regex_nonportable_escape,
     },
-    {
-      reason: "empty_subexpression",
-      outcome: "undefined_syntax",
-      rule: missing("empty_subexpression"),
-    },
     {
       reason: "unclosed_subexpression",
       outcome: "undefined_syntax",
@@ -1032,49 +1597,67 @@ function issueDefinitions(mode) {
           {
             reason: "unmatched_subexpression_close",
             outcome: "undefined_syntax",
-            rule: ($) =>
-              namedExternal(
-                $,
-                $._regex_unmatched_group_close,
-                "back_close_parenthesis",
-              ),
+            rule: ($) => $._regex_unmatched_group_close,
           },
           {
             reason: "unmatched_interval_close",
             outcome: "undefined_syntax",
-            rule: ($) =>
-              namedExternal(
-                $,
-                $._regex_unmatched_interval_close,
-                "back_close_brace",
-              ),
+            rule: ($) => $._regex_unmatched_interval_close,
           },
         ]
       : []),
     {
-      reason: "malformed_interval",
+      reason: "invalid_interval_character",
+      outcome: "undefined_syntax",
+      rule: ($) => $._regex_invalid_interval,
+    },
+    {
+      reason: "unexpected_interval_separator",
       outcome: "undefined_syntax",
       rule: ($) =>
-        prec.right(
-          repeat1(
-            choice(
-              $._regex_invalid_interval,
-              issueField($, "invalid_regular_expression_character"),
-              issueField($, "invalid_encoding"),
-            ),
-          ),
+        choice(
+          alias($._regex_interval_separator, ","),
+          alias($._regex_interval_escaped_separator, $.escaped_delimiter),
         ),
     },
+    {
+      reason: "missing_interval_minimum",
+      outcome: "undefined_syntax",
+      rule: ($) => $._regex_missing_interval_minimum,
+    },
+    {
+      id: "incomplete_interval_minimum",
+      reason: "missing_interval_minimum",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._regex_incomplete_interval_minimum,
+    },
+    {
+      reason: "missing_interval_close",
+      outcome: "undefined_syntax",
+      rule: ($) => $._regex_missing_interval_close,
+    },
+    ...(mode === "bre"
+      ? [
+          {
+            reason: "invalid_interval_close",
+            outcome: "undefined_syntax",
+            rule: ($) => $._regex_invalid_interval_close,
+          },
+          {
+            id: "incomplete_interval_close",
+            reason: "invalid_interval_close",
+            outcome: "incomplete_syntax",
+            rule: ($) => $._regex_incomplete_interval_close,
+          },
+        ]
+      : []),
     {
       reason: "leading_duplication_symbol",
       outcome: "undefined_syntax",
       rule: ($) =>
         seq(
           $._regex_leading_duplication_marker,
-          field(
-            "operator",
-            mode === "bre" ? $.bre_dupl_symbol : $.ere_dupl_symbol,
-          ),
+          field("operator", $[regularExpressionRules[mode].duplication]),
         ),
     },
     {
@@ -1083,10 +1666,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         seq(
           $._regex_adjacent_duplication_marker,
-          field(
-            "operator",
-            mode === "bre" ? $.bre_dupl_symbol : $.ere_dupl_symbol,
-          ),
+          field("operator", $[regularExpressionRules[mode].duplication]),
         ),
     },
     ...(mode === "ere"
@@ -1114,7 +1694,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._translate_nonportable_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     {
@@ -1143,27 +1723,22 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._replacement_nonportable_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     {
       reason: "special_delimiter_escape",
       outcome: "unspecified_syntax",
       rule: ($) =>
-        namedExternal(
-          $,
-          $._regex_special_escaped_delimiter,
-          "escaped_delimiter",
-        ),
+        alias($._regex_special_escaped_delimiter, $.escaped_delimiter),
     },
     {
       reason: "replacement_ampersand_delimiter_escape",
       outcome: "unspecified_syntax",
       rule: ($) =>
-        namedExternal(
-          $,
+        alias(
           $._replacement_ampersand_escaped_delimiter,
-          "replacement_escaped_delimiter",
+          $.replacement_escaped_delimiter,
         ),
     },
     {
@@ -1172,7 +1747,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._text_unspecified_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     ...(mode === "bre"
@@ -1180,29 +1755,17 @@ function issueDefinitions(mode) {
           {
             reason: "bre_vertical_line_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_vertical_line_escape, "back_bar"),
-              ),
+            rule: ($) => $._regex_bre_vertical_line_escape,
           },
           {
             reason: "bre_question_mark_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_question_mark_escape, "back_qm"),
-              ),
+            rule: ($) => $._regex_bre_question_mark_escape,
           },
           {
             reason: "bre_plus_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_plus_escape, "back_plus"),
-              ),
+            rule: ($) => $._regex_bre_plus_escape,
           },
           {
             reason: "bre_subexpression_left_anchor",
@@ -1221,6 +1784,12 @@ function issueDefinitions(mode) {
       outcome: "nonconforming_syntax",
       rule: missing("omitted_file_separator"),
     },
+    {
+      id: "incomplete_omitted_file_separator",
+      reason: "omitted_file_separator",
+      outcome: "incomplete_syntax",
+      rule: missing("incomplete_omitted_file_separator"),
+    },
     {
       reason: "excess_address",
       outcome: "nonconforming_syntax",
@@ -1245,8 +1814,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           token(prec(-2, unknownFunctionCharacter)),
-          $._nul_character,
-          issueField($, "invalid_encoding"),
+          $._single_nul_character,
         ),
     },
     {
@@ -1259,11 +1827,14 @@ function issueDefinitions(mode) {
       reason: "unexpected_command_text",
       outcome: "nonconforming_syntax",
       rule: ($) =>
-        repeat1(
-          choice(
-            $._unexpected_command_text,
-            issueField($, "nul_character"),
-            issueField($, "invalid_encoding"),
+        seq(
+          choice($._unexpected_command_text, issueField($, "nul_character")),
+          repeat(
+            choice(
+              $._unexpected_command_text,
+              issueField($, "nul_character"),
+              issueField($, "invalid_encoding"),
+            ),
           ),
         ),
     },
@@ -1272,6 +1843,12 @@ function issueDefinitions(mode) {
       outcome: "nonconforming_syntax",
       rule: ($) => alias(token.immediate(";"), $.command_separator),
     },
+    {
+      id: "incomplete_command_text",
+      reason: "unexpected_command_text",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._incomplete_command_text,
+    },
     {
       reason: "blanks_around_address_separator",
       outcome: "nonconforming_syntax",
@@ -1310,24 +1887,41 @@ function issueDefinitions(mode) {
       rule: missing("missing_separator_after_unmatched_brace"),
     },
     {
-      reason: "invalid_substitution_flag",
-      outcome: "nonconforming_syntax",
+      id: "undefined_write_command_separator",
+      reason: "forbidden_command_separator",
+      outcome: "undefined_syntax",
+      rule: ($) => alias($._write_following_separator, $.command_separator),
+    },
+    {
+      reason: "nonfinal_write_flag",
+      outcome: "undefined_syntax",
       rule: ($) =>
-        choice(
-          $._invalid_substitution_flag,
-          $._nul_character,
-          issueField($, "invalid_encoding"),
+        seq(
+          field("verb", alias("w", $.substitution_flag)),
+          $._flag_after_write_marker,
         ),
     },
+    {
+      id: "conflicting_global_flag",
+      reason: "conflicting_substitution_flag",
+      outcome: "unspecified_syntax",
+      rule: ($) => alias("g", $.global_flag),
+    },
+    {
+      id: "conflicting_occurrence_flag",
+      reason: "conflicting_substitution_flag",
+      outcome: "unspecified_syntax",
+      rule: ($) => $.occurrence_flag,
+    },
+    {
+      reason: "invalid_substitution_flag",
+      outcome: "nonconforming_syntax",
+      rule: ($) => $._invalid_substitution_flag,
+    },
     {
       reason: "invalid_delimiter",
       outcome: "nonconforming_syntax",
-      rule: ($) =>
-        choice(
-          token(/\\/),
-          $._nul_character,
-          issueField($, "invalid_encoding"),
-        ),
+      rule: ($) => choice(token(/\\/), $._single_nul_character),
     },
     {
       reason: "unterminated_regular_expression",
@@ -1368,11 +1962,6 @@ function issueDefinitions(mode) {
       outcome: "incomplete_syntax",
       rule: rule ?? missing(reason),
     })),
-    {
-      reason: "missing_subexpression",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_subexpression"),
-    },
     {
       id: "incomplete_unclosed_subexpression",
       reason: "unclosed_subexpression",
@@ -1380,7 +1969,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._regex_incomplete_group,
     },
     {
-      reason: "incomplete_bracket_term",
+      id: "incomplete_bracket_term",
+      reason: "missing_bracket_term_close",
       outcome: "incomplete_syntax",
       rule: ($) => $._regex_incomplete_bracket_term,
     },
@@ -1399,14 +1989,16 @@ function issueDefinitions(mode) {
     ...(mode === "ere"
       ? [
           {
-            reason: "incomplete_alternative",
+            id: "incomplete_alternative",
+            reason: "empty_alternative",
             outcome: "incomplete_syntax",
             rule: ($) => $._incomplete_alternative_marker,
           },
         ]
       : []),
     {
-      reason: "incomplete_interval",
+      id: "incomplete_interval",
+      reason: "missing_interval_close",
       outcome: "incomplete_syntax",
       rule: ($) => $._regex_incomplete_interval,
     },
@@ -1417,7 +2009,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._incomplete_command_separator_marker,
     },
     {
-      reason: "incomplete_regular_expression",
+      id: "incomplete_regular_expression",
+      reason: "unterminated_regular_expression",
       outcome: "incomplete_syntax",
       rule: ($) =>
         choice($._regex_unterminated_address, $._regex_unterminated_substitute),
@@ -1428,7 +2021,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._regex_incomplete_escape,
     },
     {
-      reason: "incomplete_replacement",
+      id: "incomplete_replacement",
+      reason: "unterminated_replacement",
       outcome: "incomplete_syntax",
       rule: ($) => $._replacement_unterminated,
     },
@@ -1438,7 +2032,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._replacement_incomplete_escape,
     },
     {
-      reason: "incomplete_translation",
+      id: "incomplete_translation",
+      reason: "unterminated_translation",
       outcome: "incomplete_syntax",
       rule: ($) =>
         choice(
@@ -1454,140 +2049,155 @@ function issueDefinitions(mode) {
   ];
 }
 
-function externalTokens($, mode) {
+export function externalTokens(mode) {
   return [
-    $._regex_address_start,
-    $._escaped_regex_address_start,
-    $._regex_address_end,
-    $._substitute_start,
-    $._substitute_middle,
-    $._substitute_end,
-    $._translate_start,
-    $._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,
-    $._regex_group_open,
-    $._regex_group_close,
-    $._regex_unclosed_group,
+    "regex_address_start",
+    "escaped_regex_address_start",
+    "regex_address_end",
+    "substitute_start",
+    "substitute_middle",
+    "substitute_end",
+    "translate_start",
+    "translate_middle",
+    "translate_end",
+    "regex_literal",
+    "invalid_character",
+    "nul_character",
+    "single_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",
+    "regex_group_open",
+    "regex_group_close",
+    "regex_unclosed_group",
     ...(mode === "bre"
       ? [
-          $._regex_unmatched_group_close,
-          $._regex_bre_vertical_line_escape,
-          $._regex_bre_question_mark_escape,
-          $._regex_bre_plus_escape,
-          $._regex_bre_subexpression_caret,
-          $._regex_bre_subexpression_dollar,
-          $._regex_unmatched_interval_close,
+          "regex_unmatched_group_close",
+          "regex_bre_vertical_line_escape",
+          "regex_bre_question_mark_escape",
+          "regex_bre_plus_escape",
+          "regex_bre_subexpression_caret",
+          "regex_bre_subexpression_dollar",
+          "regex_unmatched_interval_close",
         ]
       : []),
-    ...(mode === "ere" ? [$._regex_alternation_operator] : []),
-    $._regex_leading_duplication_marker,
-    $._regex_adjacent_duplication_marker,
-    $._regex_zero_or_more,
+    ...(mode === "ere" ? ["regex_alternation_operator"] : []),
+    "regex_leading_duplication_marker",
+    "regex_adjacent_duplication_marker",
+    "regex_zero_or_more",
     ...(mode === "ere"
-      ? [
-          $._regex_one_or_more,
-          $._regex_zero_or_one,
-          $._regex_repetition_modifier,
-        ]
+      ? ["regex_one_or_more", "regex_zero_or_one", "regex_repetition_modifier"]
       : []),
-    $._regex_interval_open,
-    $._regex_dup_count,
-    $._regex_interval_separator,
-    $._regex_interval_close,
-    ...(mode === "bre" ? [$._regex_backreference] : []),
-    $._regex_invalid_interval,
-    $._regex_nonportable_escape,
-    $._regex_incomplete_escape,
-    $._regex_bracket_open,
-    $._regex_bracket_close,
-    $._regex_bracket_literal,
-    $._regex_bracket_negation,
-    $._regex_bracket_hyphen,
-    $._regex_bracket_range_end_hyphen,
-    $._regex_bracket_trailing_hyphen,
-    $._regex_open_colon,
-    $._regex_class_name,
-    $._regex_invalid_class_name,
-    $._regex_colon_close,
-    $._regex_open_dot,
-    $._regex_coll_elem_single,
-    $._regex_coll_elem_multi,
-    $._regex_meta_char,
-    $._regex_dot_close,
-    $._regex_open_equal,
-    $._regex_equal_close,
-    $._regex_malformed_bracket_term,
-    $._regex_shared_range_endpoint,
-    $._ambiguous_bracket_expression_marker,
-    $._missing_bracket_list_marker,
-    $._unclosed_bracket_expression_marker,
-    $._nonportable_range_start_marker,
-    $._nonportable_range_end_marker,
-    $._regex_unterminated_address,
-    $._regex_unterminated_substitute,
-    $._replacement_literal,
-    $._replacement_match_reference,
-    $._replacement_backreference,
-    $._replacement_escaped_delimiter,
-    $._replacement_ampersand_escaped_delimiter,
-    $._replacement_escape_sequence,
-    $._replacement_nonportable_escape,
-    $._replacement_escaped_newline,
-    $._replacement_incomplete_escape,
-    $._replacement_unterminated,
-    $._translate_literal,
-    $._translate_escaped_delimiter,
-    $._translate_escape,
-    $._translate_nonportable_escape,
-    $._translate_incomplete_escape,
-    $._translate_unterminated_source,
-    $._translate_unterminated_destination,
-    $._invalid_substitution_flag,
-    $._flag_after_write_marker,
-    $._text_command_start,
-    $._text_incomplete_introducer,
-    $._text_literal,
-    $._text_backslash_escape,
-    $._text_escaped_newline,
-    $._text_unspecified_escape,
-    $._text_line_end,
-    $._text_eof,
-    $._default_output_suppression,
-    $._comment_text,
-    $._file_argument,
-    $._substitution_wfile_argument,
-    $._substitution_wfile_continuation,
-    $._line_word,
-    $._argument_separator,
-    $._right_brace,
-    $._brace_leading_blanks,
-    $._block_trailing_blanks,
-    $._empty_command_marker,
-    $._reserved_unknown_function_token,
-    $._regex_incomplete_group,
-    $._regex_incomplete_bracket_term,
-    $._regex_incomplete_interval,
-    $._regex_forbidden_newline_escape,
-    $._regex_line_unterminated_address,
-    $._regex_line_unterminated_substitute,
-    $._replacement_line_unterminated,
-    $._translate_line_unterminated_source,
-    $._translate_line_unterminated_destination,
-    $._blanks_around_address_separator,
-    ...missingMarkerNames(mode).map((name) => $[`_${name}_marker`]),
-    $._unexpected_command_text,
-    $._error_sentinel,
+    "regex_interval_open",
+    "regex_dup_count",
+    "regex_interval_escaped_count",
+    "regex_interval_escaped_separator",
+    "regex_interval_separator",
+    "regex_interval_close",
+    ...(mode === "bre" ? ["regex_backreference"] : []),
+    "regex_invalid_interval",
+    "regex_missing_interval_minimum",
+    "regex_incomplete_interval_minimum",
+    "regex_missing_interval_close",
+    ...(mode === "bre"
+      ? ["regex_invalid_interval_close", "regex_incomplete_interval_close"]
+      : []),
+    "regex_nonportable_escape",
+    "regex_incomplete_escape",
+    "regex_bracket_open",
+    "regex_bracket_close",
+    "regex_bracket_literal",
+    "regex_bracket_negation",
+    "regex_bracket_hyphen",
+    "regex_bracket_range_end_hyphen",
+    "regex_bracket_trailing_hyphen",
+    "regex_open_colon",
+    "regex_class_name",
+    "regex_invalid_class_name",
+    "regex_colon_close",
+    "regex_open_dot",
+    "regex_coll_elem_single",
+    "regex_coll_elem_multi",
+    "regex_meta_char",
+    "regex_incomplete_meta_char",
+    "regex_dot_close",
+    "regex_open_equal",
+    "regex_equal_close",
+    "regex_missing_bracket_term_close",
+    "regex_missing_bracket_term_payload",
+    "regex_incomplete_bracket_term_payload",
+    "regex_shared_range_endpoint",
+    "ambiguous_bracket_expression_marker",
+    "missing_bracket_list_marker",
+    "unclosed_bracket_expression_marker",
+    "nonportable_range_start_marker",
+    "nonportable_range_end_marker",
+    "regex_unterminated_address",
+    "regex_unterminated_substitute",
+    "replacement_literal",
+    "replacement_match_reference",
+    "replacement_backreference",
+    "replacement_escaped_delimiter",
+    "replacement_ampersand_escaped_delimiter",
+    "replacement_escape_sequence",
+    "replacement_nonportable_escape",
+    "replacement_escaped_newline",
+    "replacement_incomplete_escape",
+    "replacement_unterminated",
+    "translate_literal",
+    "translate_escaped_delimiter",
+    "translate_escape",
+    "translate_nonportable_escape",
+    "translate_incomplete_escape",
+    "translate_unterminated_source",
+    "translate_unterminated_destination",
+    "invalid_substitution_flag",
+    "flag_after_write_marker",
+    "write_terminal_separator",
+    "write_block_terminal_separator",
+    "write_following_separator",
+    "text_command_start",
+    "text_incomplete_introducer",
+    "text_literal",
+    "text_backslash_escape",
+    "text_escaped_newline",
+    "text_unspecified_escape",
+    "text_line_end",
+    "text_eof",
+    "default_output_suppression",
+    "comment_text",
+    "file_argument",
+    "substitution_wfile_argument",
+    "substitution_wfile_continuation",
+    "line_word",
+    "label_start",
+    "long_label_start",
+    "label_literal",
+    "nonportable_label_character",
+    "argument_separator",
+    "brace_leading_blanks",
+    "block_trailing_blanks",
+    "empty_command_marker",
+    "reserved_unknown_function_token",
+    "regex_incomplete_group",
+    "regex_incomplete_bracket_term",
+    "regex_incomplete_interval",
+    "regex_forbidden_newline_escape",
+    "regex_line_unterminated_address",
+    "regex_line_unterminated_substitute",
+    "replacement_line_unterminated",
+    "translate_line_unterminated_source",
+    "translate_line_unterminated_destination",
+    "blanks_around_address_separator",
+    ...missingMarkerNames(mode).map((name) => `${name}_marker`),
+    "unexpected_command_text",
+    "incomplete_command_text",
+    "error_sentinel",
   ];
 }
 
@@ -1596,10 +2206,10 @@ function defineGrammar(name, mode) {
     throw new Error(`Unsupported regular-expression mode: ${mode}`);
   }
 
-  return grammar({
+  const options = {
     name,
 
-    externals: ($) => externalTokens($, mode),
+    externals: ($) => externalTokens(mode).map((name) => $[`_${name}`]),
 
     extras: () => [],
 
@@ -1618,13 +2228,12 @@ function defineGrammar(name, mode) {
         $._omitted_first_address_unit1_reason,
       ],
     ],
-
-    rules: {
-      ...sedRules(mode),
-      ...regularExpressionRules(mode),
-      ...defineIssueRules(issueDefinitions(mode)),
-    },
-  });
+  };
+  const rules = sedRules(mode);
+  const issues = defineIssueRules(issueDefinitions(mode));
+  return mode === "bre"
+    ? grammar({ ...options, rules: { ...rules, ...breRules(), ...issues } })
+    : grammar({ ...options, rules: { ...rules, ...ereRules(), ...issues } });
 }
 
 export default defineGrammar;