herb 0.10.1 → 0.11.1

data/src/errors.c

@@ -1,7 +1,8 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/errors.c.erb
+// be modified manually. See templates/src/errors.c.erb
 
 #include "include/errors.h"
+#include "include/parser/parser.h"
 #include "include/location/location.h"
 #include "include/location/position.h"
 #include "include/ast/pretty_print.h"
@@ -69,8 +70,12 @@ UNEXPECTED_ERROR_T* unexpected_error_init(hb_string_T description, hb_string_T e
   return unexpected_error;
 }
 
-void append_unexpected_error(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unexpected_error_init(description, expected, found, start, end, allocator));
+void append_unexpected_error(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_error_init(description, expected, found, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -108,8 +113,12 @@ UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type
   return unexpected_token_error;
 }
 
-void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unexpected_token_error_init(expected_type, found, start, end, allocator));
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_token_error_init(expected_type, found, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -141,8 +150,12 @@ MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag
   return missing_opening_tag_error;
 }
 
-void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, missing_opening_tag_error_init(closing_tag, start, end, allocator));
+void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, missing_opening_tag_error_init(closing_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -179,8 +192,12 @@ MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag
   return missing_closing_tag_error;
 }
 
-void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, missing_closing_tag_error_init(opening_tag, start, end, allocator));
+void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, missing_closing_tag_error_init(opening_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -220,8 +237,12 @@ TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag,
   return tag_names_mismatch_error;
 }
 
-void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end, allocator));
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -268,8 +289,12 @@ VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* t
   return void_element_closing_tag_error;
 }
 
-void append_void_element_closing_tag_error(token_T* tag_name, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end, allocator));
+void append_void_element_closing_tag_error(token_T* tag_name, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -301,8 +326,12 @@ UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, posi
   return unclosed_element_error;
 }
 
-void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_element_error_init(opening_tag, start, end, allocator));
+void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_element_error_init(opening_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_init(hb_string_T error_message, hb_string_T diagnostic_id, hb_string_T level, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -339,8 +368,12 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_init(hb_string_T error_message, hb_string_T
   return ruby_parse_error;
 }
 
-void append_ruby_parse_error(hb_string_T error_message, hb_string_T diagnostic_id, hb_string_T level, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end, allocator));
+void append_ruby_parse_error(hb_string_T error_message, hb_string_T diagnostic_id, hb_string_T level, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -370,8 +403,12 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(hb_string_T ke
   return erb_control_flow_scope_error;
 }
 
-void append_erb_control_flow_scope_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, erb_control_flow_scope_error_init(keyword, start, end, allocator));
+void append_erb_control_flow_scope_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, erb_control_flow_scope_error_init(keyword, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error_init(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -401,8 +438,12 @@ MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error_init(hb_string_T keyword,
   return missing_erb_end_tag_error;
 }
 
-void append_missing_erb_end_tag_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, missing_erb_end_tag_error_init(keyword, start, end, allocator));
+void append_missing_erb_end_tag_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, missing_erb_end_tag_error_init(keyword, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -417,8 +458,12 @@ ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(positi
   return erb_multiple_blocks_in_tag_error;
 }
 
-void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end, allocator));
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, erb_multiple_blocks_in_tag_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -428,13 +473,37 @@ ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T
 
   error_init(&erb_case_with_conditions_error->base, ERB_CASE_WITH_CONDITIONS_ERROR, start, end);
 
-  erb_case_with_conditions_error->base.message = hb_string_copy(hb_string("A `case` statement with `when`/`in` conditions in a single ERB tag cannot be reliably parsed, compiled, and formatted. Use separate ERB tags for `case` and its conditions (e.g., `<% case x %>` followed by `<% when y %>`)."), allocator);
+  erb_case_with_conditions_error->base.message = hb_string_copy(hb_string("A `case` statement with `when`/`in` conditions in a single ERB tag cannot be reliably parsed, compiled, and formatted. Use separate ERB tags for `case` and its conditions (e.g., `<% case x %>` followed by `<% when y %>`), or set `strict: false` to allow this."), allocator);
 
   return erb_case_with_conditions_error;
 }
 
-void append_erb_case_with_conditions_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, erb_case_with_conditions_error_init(start, end, allocator));
+void append_erb_case_with_conditions_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, erb_case_with_conditions_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T* erb_case_inline_pattern_match_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T* erb_case_inline_pattern_match_error = hb_allocator_alloc(allocator, sizeof(ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T));
+
+  if (!erb_case_inline_pattern_match_error) { return NULL; }
+
+  error_init(&erb_case_inline_pattern_match_error->base, ERB_CASE_INLINE_PATTERN_MATCH_ERROR, start, end);
+
+  erb_case_inline_pattern_match_error->base.message = hb_string_copy(hb_string("A `case` statement and its first `in` pattern on the same line read as Ruby's one-line pattern match, not as a `case`/`in`. Put the `in` pattern on its own line, or in its own ERB tag (e.g., `<% case x %>` followed by `<% in y %>`)."), allocator);
+
+  return erb_case_inline_pattern_match_error;
+}
+
+void append_erb_case_inline_pattern_match_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, erb_case_inline_pattern_match_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error_init(size_t line, size_t column, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -462,8 +531,12 @@ CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_err
   return conditional_element_multiple_tags_error;
 }
 
-void append_conditional_element_multiple_tags_error(size_t line, size_t column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, conditional_element_multiple_tags_error_init(line, column, start, end, allocator));
+void append_conditional_element_multiple_tags_error(size_t line, size_t column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, conditional_element_multiple_tags_error_init(line, column, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error_init(hb_string_T tag_name, hb_string_T open_condition, size_t open_line, size_t open_column, hb_string_T close_condition, size_t close_line, size_t close_column, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -513,8 +586,79 @@ CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mi
   return conditional_element_condition_mismatch_error;
 }
 
-void append_conditional_element_condition_mismatch_error(hb_string_T tag_name, hb_string_T open_condition, size_t open_line, size_t open_column, hb_string_T close_condition, size_t close_line, size_t close_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, conditional_element_condition_mismatch_error_init(tag_name, open_condition, open_line, open_column, close_condition, close_line, close_column, start, end, allocator));
+void append_conditional_element_condition_mismatch_error(hb_string_T tag_name, hb_string_T open_condition, size_t open_line, size_t open_column, hb_string_T close_condition, size_t close_line, size_t close_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, conditional_element_condition_mismatch_error_init(tag_name, open_condition, open_line, open_column, close_condition, close_line, close_column, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+UNCLOSED_COMMENT_ERROR_T* unclosed_comment_error_init(token_T* comment_start, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_COMMENT_ERROR_T* unclosed_comment_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_COMMENT_ERROR_T));
+
+  if (!unclosed_comment_error) { return NULL; }
+
+  error_init(&unclosed_comment_error->base, UNCLOSED_COMMENT_ERROR, start, end);
+
+  const char* message_template = "Comment opened at (%u:%u) is missing its closing `-->`.";
+
+  char message[76];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    comment_start->location.start.line,
+    comment_start->location.start.column
+  );
+
+  unclosed_comment_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_comment_error->comment_start = token_copy(comment_start, allocator);
+  return unclosed_comment_error;
+}
+
+void append_unclosed_comment_error(token_T* comment_start, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_comment_error_init(comment_start, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+NESTED_COMMENT_ERROR_T* nested_comment_error_init(token_T* comment_start, token_T* nested_start, position_T start, position_T end, hb_allocator_T* allocator) {
+  NESTED_COMMENT_ERROR_T* nested_comment_error = hb_allocator_alloc(allocator, sizeof(NESTED_COMMENT_ERROR_T));
+
+  if (!nested_comment_error) { return NULL; }
+
+  error_init(&nested_comment_error->base, NESTED_COMMENT_ERROR, start, end);
+
+  const char* message_template = "Comment opened at (%u:%u) contains another `<!--` at (%u:%u).";
+
+  char message[102];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    comment_start->location.start.line,
+    comment_start->location.start.column,
+    nested_start->location.start.line,
+    nested_start->location.start.column
+  );
+
+  nested_comment_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  nested_comment_error->comment_start = token_copy(comment_start, allocator);
+  nested_comment_error->nested_start = token_copy(nested_start, allocator);
+  return nested_comment_error;
+}
+
+void append_nested_comment_error(token_T* comment_start, token_T* nested_start, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, nested_comment_error_init(comment_start, nested_start, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error_init(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -546,8 +690,12 @@ INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error_init(toke
   return invalid_comment_closing_tag_error;
 }
 
-void append_invalid_comment_closing_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, invalid_comment_closing_tag_error_init(closing_tag, start, end, allocator));
+void append_invalid_comment_closing_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, invalid_comment_closing_tag_error_init(closing_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error_init(token_T* opening_tag, position_T insertion_point, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -587,8 +735,12 @@ OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error_init(token_T* opening_tag
   return omitted_closing_tag_error;
 }
 
-void append_omitted_closing_tag_error(token_T* opening_tag, position_T insertion_point, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, omitted_closing_tag_error_init(opening_tag, insertion_point, start, end, allocator));
+void append_omitted_closing_tag_error(token_T* opening_tag, position_T insertion_point, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, omitted_closing_tag_error_init(opening_tag, insertion_point, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error_init(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -620,8 +772,12 @@ UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error_init(token_T* tag_name, posit
   return unclosed_open_tag_error;
 }
 
-void append_unclosed_open_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_open_tag_error_init(tag_name, start, end, allocator));
+void append_unclosed_open_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_open_tag_error_init(tag_name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error_init(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -653,8 +809,49 @@ UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error_init(token_T* tag_name, pos
   return unclosed_close_tag_error;
 }
 
-void append_unclosed_close_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_close_tag_error_init(tag_name, start, end, allocator));
+void append_unclosed_close_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_close_tag_error_init(tag_name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T* end_tag_with_trailing_solidus_error_init(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator) {
+  END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T* end_tag_with_trailing_solidus_error = hb_allocator_alloc(allocator, sizeof(END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T));
+
+  if (!end_tag_with_trailing_solidus_error) { return NULL; }
+
+  error_init(&end_tag_with_trailing_solidus_error->base, END_TAG_WITH_TRAILING_SOLIDUS_ERROR, start, end);
+
+  const char* message_template = "Closing tag `</%s>` at (%u:%u) ends with `/>` instead of `>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[210];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    tag_name->location.start.line,
+    tag_name->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  end_tag_with_trailing_solidus_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  end_tag_with_trailing_solidus_error->tag_name = token_copy(tag_name, allocator);
+  return end_tag_with_trailing_solidus_error;
+}
+
+void append_end_tag_with_trailing_solidus_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, end_tag_with_trailing_solidus_error_init(tag_name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error_init(token_T* opening_quote, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -686,8 +883,12 @@ UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error_init(token_T* opening_quote, positi
   return unclosed_quote_error;
 }
 
-void append_unclosed_quote_error(token_T* opening_quote, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_quote_error_init(opening_quote, start, end, allocator));
+void append_unclosed_quote_error(token_T* opening_quote, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_quote_error_init(opening_quote, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error_init(hb_string_T attribute_name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -719,8 +920,187 @@ MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error_init(hb_string_T
   return missing_attribute_value_error;
 }
 
-void append_missing_attribute_value_error(hb_string_T attribute_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, missing_attribute_value_error_init(attribute_name, start, end, allocator));
+void append_missing_attribute_value_error(hb_string_T attribute_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, missing_attribute_value_error_init(attribute_name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T* missing_whitespace_between_attributes_error_init(token_T* found, position_T start, position_T end, hb_allocator_T* allocator) {
+  MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T* missing_whitespace_between_attributes_error = hb_allocator_alloc(allocator, sizeof(MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T));
+
+  if (!missing_whitespace_between_attributes_error) { return NULL; }
+
+  error_init(&missing_whitespace_between_attributes_error->base, MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR, start, end);
+
+  const char* message_template = "Missing whitespace between attributes at (%u:%u). `%s` is parsed as the start of a new attribute.";
+
+  hb_string_T truncated_argument_2 = hb_string_truncate(found->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_2 = hb_string_to_c_string_using_malloc(truncated_argument_2);
+
+  char message[246];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    found->location.start.line,
+    found->location.start.column,
+    truncated_c_string_2 ? truncated_c_string_2 : ""
+  );
+
+  if (truncated_c_string_2) { free(truncated_c_string_2); }
+  missing_whitespace_between_attributes_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  missing_whitespace_between_attributes_error->found = token_copy(found, allocator);
+  return missing_whitespace_between_attributes_error;
+}
+
+void append_missing_whitespace_between_attributes_error(token_T* found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, missing_whitespace_between_attributes_error_init(found, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T* unexpected_character_in_attribute_name_error_init(token_T* character, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T* unexpected_character_in_attribute_name_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T));
+
+  if (!unexpected_character_in_attribute_name_error) { return NULL; }
+
+  error_init(&unexpected_character_in_attribute_name_error->base, UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR, start, end);
+
+  const char* message_template = "Unexpected `%s` in attribute name at (%u:%u).";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(character->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[194];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    character->location.start.line,
+    character->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unexpected_character_in_attribute_name_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unexpected_character_in_attribute_name_error->character = token_copy(character, allocator);
+  return unexpected_character_in_attribute_name_error;
+}
+
+void append_unexpected_character_in_attribute_name_error(token_T* character, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_character_in_attribute_name_error_init(character, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T* unexpected_character_in_unquoted_attribute_value_error_init(token_T* character, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T* unexpected_character_in_unquoted_attribute_value_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T));
+
+  if (!unexpected_character_in_unquoted_attribute_value_error) { return NULL; }
+
+  error_init(&unexpected_character_in_unquoted_attribute_value_error->base, UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR, start, end);
+
+  const char* message_template = "Unexpected `%s` in unquoted attribute value at (%u:%u).";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(character->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[204];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    character->location.start.line,
+    character->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unexpected_character_in_unquoted_attribute_value_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unexpected_character_in_unquoted_attribute_value_error->character = token_copy(character, allocator);
+  return unexpected_character_in_unquoted_attribute_value_error;
+}
+
+void append_unexpected_character_in_unquoted_attribute_value_error(token_T* character, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_character_in_unquoted_attribute_value_error_init(character, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T* unexpected_equals_sign_before_attribute_name_error_init(token_T* equals, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T* unexpected_equals_sign_before_attribute_name_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T));
+
+  if (!unexpected_equals_sign_before_attribute_name_error) { return NULL; }
+
+  error_init(&unexpected_equals_sign_before_attribute_name_error->base, UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR, start, end);
+
+  const char* message_template = "Unexpected `=` before attribute name at (%u:%u).";
+
+  char message[69];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    equals->location.start.line,
+    equals->location.start.column
+  );
+
+  unexpected_equals_sign_before_attribute_name_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unexpected_equals_sign_before_attribute_name_error->equals = token_copy(equals, allocator);
+  return unexpected_equals_sign_before_attribute_name_error;
+}
+
+void append_unexpected_equals_sign_before_attribute_name_error(token_T* equals, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_equals_sign_before_attribute_name_error_init(equals, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T* unexpected_solidus_in_tag_error_init(token_T* solidus, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T* unexpected_solidus_in_tag_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T));
+
+  if (!unexpected_solidus_in_tag_error) { return NULL; }
+
+  error_init(&unexpected_solidus_in_tag_error->base, UNEXPECTED_SOLIDUS_IN_TAG_ERROR, start, end);
+
+  const char* message_template = "Unexpected `/` in tag at (%u:%u).";
+
+  char message[54];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    solidus->location.start.line,
+    solidus->location.start.column
+  );
+
+  unexpected_solidus_in_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unexpected_solidus_in_tag_error->solidus = token_copy(solidus, allocator);
+  return unexpected_solidus_in_tag_error;
+}
+
+void append_unexpected_solidus_in_tag_error(token_T* solidus, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unexpected_solidus_in_tag_error_init(solidus, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -752,8 +1132,57 @@ UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error_init(token_T* opening_tag, posi
   return unclosed_erb_tag_error;
 }
 
-void append_unclosed_erb_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_erb_tag_error_init(opening_tag, start, end, allocator));
+void append_unclosed_erb_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, unclosed_erb_tag_error_init(opening_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+MALFORMED_ERB_CLOSING_TAG_ERROR_T* malformed_erb_closing_tag_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  MALFORMED_ERB_CLOSING_TAG_ERROR_T* malformed_erb_closing_tag_error = hb_allocator_alloc(allocator, sizeof(MALFORMED_ERB_CLOSING_TAG_ERROR_T));
+
+  if (!malformed_erb_closing_tag_error) { return NULL; }
+
+  error_init(&malformed_erb_closing_tag_error->base, MALFORMED_ERB_CLOSING_TAG_ERROR, start, end);
+
+  const char* message_template = "ERB tag `%s` at (%u:%u) is closed with `%s` at (%u:%u) instead of `%%>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_3 = hb_string_truncate(closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_3 = hb_string_to_c_string_using_malloc(truncated_argument_3);
+
+  char message[369];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column,
+    truncated_c_string_3 ? truncated_c_string_3 : "",
+    closing_tag->location.start.line,
+    closing_tag->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_3) { free(truncated_c_string_3); }
+  malformed_erb_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  malformed_erb_closing_tag_error->opening_tag = token_copy(opening_tag, allocator);
+  malformed_erb_closing_tag_error->closing_tag = token_copy(closing_tag, allocator);
+  return malformed_erb_closing_tag_error;
+}
+
+void append_malformed_erb_closing_tag_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, malformed_erb_closing_tag_error_init(opening_tag, closing_tag, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -779,8 +1208,12 @@ STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error_init(position_T start
   return stray_erb_closing_tag_error;
 }
 
-void append_stray_erb_closing_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, stray_erb_closing_tag_error_init(start, end, allocator));
+void append_stray_erb_closing_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, stray_erb_closing_tag_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error_init(token_T* opening_tag, size_t nested_tag_line, size_t nested_tag_column, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -816,8 +1249,12 @@ NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error_init(token_T* opening_tag, size_t n
   return nested_erb_tag_error;
 }
 
-void append_nested_erb_tag_error(token_T* opening_tag, size_t nested_tag_line, size_t nested_tag_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, nested_erb_tag_error_init(opening_tag, nested_tag_line, nested_tag_column, start, end, allocator));
+void append_nested_erb_tag_error(token_T* opening_tag, size_t nested_tag_line, size_t nested_tag_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, nested_erb_tag_error_init(opening_tag, nested_tag_line, nested_tag_column, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error_init(hb_string_T partial, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -852,8 +1289,12 @@ RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error_init(hb_string_T
   return render_ambiguous_locals_error;
 }
 
-void append_render_ambiguous_locals_error(hb_string_T partial, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_ambiguous_locals_error_init(partial, start, end, allocator));
+void append_render_ambiguous_locals_error(hb_string_T partial, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_ambiguous_locals_error_init(partial, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error_init(hb_string_T partial, hb_string_T keywords, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -894,8 +1335,12 @@ RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error_init(hb_string_T part
   return render_missing_locals_error;
 }
 
-void append_render_missing_locals_error(hb_string_T partial, hb_string_T keywords, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_missing_locals_error_init(partial, keywords, start, end, allocator));
+void append_render_missing_locals_error(hb_string_T partial, hb_string_T keywords, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_missing_locals_error_init(partial, keywords, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -910,8 +1355,12 @@ RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error_init(position_T start, po
   return render_no_arguments_error;
 }
 
-void append_render_no_arguments_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_no_arguments_error_init(start, end, allocator));
+void append_render_no_arguments_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_no_arguments_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error_init(hb_string_T positional_partial, hb_string_T keyword_partial, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -947,8 +1396,12 @@ RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error_init(hb_str
   return render_conflicting_partial_error;
 }
 
-void append_render_conflicting_partial_error(hb_string_T positional_partial, hb_string_T keyword_partial, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_conflicting_partial_error_init(positional_partial, keyword_partial, start, end, allocator));
+void append_render_conflicting_partial_error(hb_string_T positional_partial, hb_string_T keyword_partial, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_conflicting_partial_error_init(positional_partial, keyword_partial, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error_init(hb_string_T as_value, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -978,8 +1431,12 @@ RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error_init(hb_string_
   return render_invalid_as_option_error;
 }
 
-void append_render_invalid_as_option_error(hb_string_T as_value, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_invalid_as_option_error_init(as_value, start, end, allocator));
+void append_render_invalid_as_option_error(hb_string_T as_value, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_invalid_as_option_error_init(as_value, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -994,8 +1451,12 @@ RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error_init(po
   return render_object_and_collection_error;
 }
 
-void append_render_object_and_collection_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_object_and_collection_error_init(start, end, allocator));
+void append_render_object_and_collection_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_object_and_collection_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error_init(hb_string_T layout, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1025,8 +1486,12 @@ RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error_init(hb_s
   return render_layout_without_block_error;
 }
 
-void append_render_layout_without_block_error(hb_string_T layout, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, render_layout_without_block_error_init(layout, start, end, allocator));
+void append_render_layout_without_block_error(hb_string_T layout, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, render_layout_without_block_error_init(layout, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1061,8 +1526,12 @@ STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_err
   return strict_locals_positional_argument_error;
 }
 
-void append_strict_locals_positional_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, strict_locals_positional_argument_error_init(name, start, end, allocator));
+void append_strict_locals_positional_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, strict_locals_positional_argument_error_init(name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1092,8 +1561,12 @@ STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error_init(hb
   return strict_locals_block_argument_error;
 }
 
-void append_strict_locals_block_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, strict_locals_block_argument_error_init(name, start, end, allocator));
+void append_strict_locals_block_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, strict_locals_block_argument_error_init(name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error_init(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1123,8 +1596,12 @@ STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error_init(hb
   return strict_locals_splat_argument_error;
 }
 
-void append_strict_locals_splat_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, strict_locals_splat_argument_error_init(name, start, end, allocator));
+void append_strict_locals_splat_argument_error(hb_string_T name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, strict_locals_splat_argument_error_init(name, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error_init(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1154,8 +1631,12 @@ STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_err
   return strict_locals_missing_parenthesis_error;
 }
 
-void append_strict_locals_missing_parenthesis_error(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, strict_locals_missing_parenthesis_error_init(rest, start, end, allocator));
+void append_strict_locals_missing_parenthesis_error(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, strict_locals_missing_parenthesis_error_init(rest, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1165,13 +1646,148 @@ STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration
 
   error_init(&strict_locals_duplicate_declaration_error->base, STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR, start, end);
 
-  strict_locals_duplicate_declaration_error->base.message = hb_string_copy(hb_string("Duplicate strict locals declaration. Only the first `<%# locals: (...) %>` declaration is used by Rails."), allocator);
+  strict_locals_duplicate_declaration_error->base.message = hb_string_copy(hb_string("Duplicate strict locals declaration. Only the first `<%# locals: (...) %>` declaration is used by Rails."), allocator);
+
+  return strict_locals_duplicate_declaration_error;
+}
+
+void append_strict_locals_duplicate_declaration_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, strict_locals_duplicate_declaration_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+HERB_STATE_MISSING_PARENTHESIS_ERROR_T* herb_state_missing_parenthesis_error_init(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator) {
+  HERB_STATE_MISSING_PARENTHESIS_ERROR_T* herb_state_missing_parenthesis_error = hb_allocator_alloc(allocator, sizeof(HERB_STATE_MISSING_PARENTHESIS_ERROR_T));
+
+  if (!herb_state_missing_parenthesis_error) { return NULL; }
+
+  error_init(&herb_state_missing_parenthesis_error->base, HERB_STATE_MISSING_PARENTHESIS_ERROR, start, end);
+
+  const char* message_template = "The `herb:state` directive requires parentheses. Expected `herb:state (...)` but got `herb:state %s`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(rest, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[230];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  herb_state_missing_parenthesis_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  herb_state_missing_parenthesis_error->rest = hb_string_copy(rest, allocator);
+  return herb_state_missing_parenthesis_error;
+}
+
+void append_herb_state_missing_parenthesis_error(hb_string_T rest, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, herb_state_missing_parenthesis_error_init(rest, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T* herb_state_non_canonical_directive_error_init(hb_string_T found, hb_string_T expected, position_T start, position_T end, hb_allocator_T* allocator) {
+  HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T* herb_state_non_canonical_directive_error = hb_allocator_alloc(allocator, sizeof(HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T));
+
+  if (!herb_state_non_canonical_directive_error) { return NULL; }
+
+  error_init(&herb_state_non_canonical_directive_error->base, HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR, start, end);
+
+  const char* message_template = "The `herb:state` directive has to be spelled `<%%# herb:state (...) %%>`. Found `%s` where `%s` was expected.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(found, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(expected, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  char message[366];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  herb_state_non_canonical_directive_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  herb_state_non_canonical_directive_error->found = hb_string_copy(found, allocator);
+  herb_state_non_canonical_directive_error->expected = hb_string_copy(expected, allocator);
+  return herb_state_non_canonical_directive_error;
+}
+
+void append_herb_state_non_canonical_directive_error(hb_string_T found, hb_string_T expected, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, herb_state_non_canonical_directive_error_init(found, expected, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+HERB_STATE_INVALID_PARAMETER_ERROR_T* herb_state_invalid_parameter_error_init(hb_string_T parameter, position_T start, position_T end, hb_allocator_T* allocator) {
+  HERB_STATE_INVALID_PARAMETER_ERROR_T* herb_state_invalid_parameter_error = hb_allocator_alloc(allocator, sizeof(HERB_STATE_INVALID_PARAMETER_ERROR_T));
+
+  if (!herb_state_invalid_parameter_error) { return NULL; }
+
+  error_init(&herb_state_invalid_parameter_error->base, HERB_STATE_INVALID_PARAMETER_ERROR, start, end);
+
+  const char* message_template = "The `herb:state` directive only declares keyword arguments with defaults. `%s` is not one. Declare each state with a default, like `(pending: false)`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(parameter, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[279];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  herb_state_invalid_parameter_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  herb_state_invalid_parameter_error->parameter = hb_string_copy(parameter, allocator);
+  return herb_state_invalid_parameter_error;
+}
+
+void append_herb_state_invalid_parameter_error(hb_string_T parameter, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, herb_state_invalid_parameter_error_init(parameter, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+HERB_STATE_DUPLICATE_DECLARATION_ERROR_T* herb_state_duplicate_declaration_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  HERB_STATE_DUPLICATE_DECLARATION_ERROR_T* herb_state_duplicate_declaration_error = hb_allocator_alloc(allocator, sizeof(HERB_STATE_DUPLICATE_DECLARATION_ERROR_T));
+
+  if (!herb_state_duplicate_declaration_error) { return NULL; }
+
+  error_init(&herb_state_duplicate_declaration_error->base, HERB_STATE_DUPLICATE_DECLARATION_ERROR, start, end);
+
+  herb_state_duplicate_declaration_error->base.message = hb_string_copy(hb_string("This scope already declares its states. Merge these states into the first `<%# herb:state (...) %>` directive of the scope, so every state of the scope reads from one declaration."), allocator);
 
-  return strict_locals_duplicate_declaration_error;
+  return herb_state_duplicate_declaration_error;
 }
 
-void append_strict_locals_duplicate_declaration_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, strict_locals_duplicate_declaration_error_init(start, end, allocator));
+void append_herb_state_duplicate_declaration_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, herb_state_duplicate_declaration_error_init(start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error_init(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1213,8 +1829,12 @@ VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error_init(token_T* tag_name,
   return void_element_content_error;
 }
 
-void append_void_element_content_error(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, void_element_content_error_init(tag_name, helper_name, content_type, start, end, allocator));
+void append_void_element_content_error(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, void_element_content_error_init(tag_name, helper_name, content_type, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error_init(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator) {
@@ -1244,8 +1864,43 @@ DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error_init(token_T* segment, po
   return dot_notation_casing_error;
 }
 
-void append_dot_notation_casing_error(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
-  hb_array_append(errors, dot_notation_casing_error_init(segment, start, end, allocator));
+void append_dot_notation_casing_error(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, dot_notation_casing_error_init(segment, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
+}
+
+TIMEOUT_ERROR_T* timeout_error_init(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator) {
+  TIMEOUT_ERROR_T* timeout_error = hb_allocator_alloc(allocator, sizeof(TIMEOUT_ERROR_T));
+
+  if (!timeout_error) { return NULL; }
+
+  error_init(&timeout_error->base, TIMEOUT_ERROR, start, end);
+
+  const char* message_template = "Parsing timed out after %zu ms.";
+
+  char message[52];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    timeout_ms
+  );
+
+  timeout_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  timeout_error->timeout_ms = timeout_ms;
+  return timeout_error;
+}
+
+void append_timeout_error(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T** errors, const struct PARSER_OPTIONS_STRUCT* options) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, timeout_error_init(timeout_ms, start, end, allocator), allocator);
+
+  parser_options_increment_error_count(options);
 }
 
 hb_string_T error_type_to_string(ERROR_T* error) {
@@ -1262,15 +1917,25 @@ hb_string_T error_type_to_string(ERROR_T* error) {
     case MISSING_ERB_END_TAG_ERROR: return hb_string("MISSING_ERB_END_TAG_ERROR");
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return hb_string("ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR");
     case ERB_CASE_WITH_CONDITIONS_ERROR: return hb_string("ERB_CASE_WITH_CONDITIONS_ERROR");
+    case ERB_CASE_INLINE_PATTERN_MATCH_ERROR: return hb_string("ERB_CASE_INLINE_PATTERN_MATCH_ERROR");
     case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: return hb_string("CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR");
     case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: return hb_string("CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR");
+    case UNCLOSED_COMMENT_ERROR: return hb_string("UNCLOSED_COMMENT_ERROR");
+    case NESTED_COMMENT_ERROR: return hb_string("NESTED_COMMENT_ERROR");
     case INVALID_COMMENT_CLOSING_TAG_ERROR: return hb_string("INVALID_COMMENT_CLOSING_TAG_ERROR");
     case OMITTED_CLOSING_TAG_ERROR: return hb_string("OMITTED_CLOSING_TAG_ERROR");
     case UNCLOSED_OPEN_TAG_ERROR: return hb_string("UNCLOSED_OPEN_TAG_ERROR");
     case UNCLOSED_CLOSE_TAG_ERROR: return hb_string("UNCLOSED_CLOSE_TAG_ERROR");
+    case END_TAG_WITH_TRAILING_SOLIDUS_ERROR: return hb_string("END_TAG_WITH_TRAILING_SOLIDUS_ERROR");
     case UNCLOSED_QUOTE_ERROR: return hb_string("UNCLOSED_QUOTE_ERROR");
     case MISSING_ATTRIBUTE_VALUE_ERROR: return hb_string("MISSING_ATTRIBUTE_VALUE_ERROR");
+    case MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR: return hb_string("MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR");
+    case UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR: return hb_string("UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR");
+    case UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR: return hb_string("UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR");
+    case UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR: return hb_string("UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR");
+    case UNEXPECTED_SOLIDUS_IN_TAG_ERROR: return hb_string("UNEXPECTED_SOLIDUS_IN_TAG_ERROR");
     case UNCLOSED_ERB_TAG_ERROR: return hb_string("UNCLOSED_ERB_TAG_ERROR");
+    case MALFORMED_ERB_CLOSING_TAG_ERROR: return hb_string("MALFORMED_ERB_CLOSING_TAG_ERROR");
     case STRAY_ERB_CLOSING_TAG_ERROR: return hb_string("STRAY_ERB_CLOSING_TAG_ERROR");
     case NESTED_ERB_TAG_ERROR: return hb_string("NESTED_ERB_TAG_ERROR");
     case RENDER_AMBIGUOUS_LOCALS_ERROR: return hb_string("RENDER_AMBIGUOUS_LOCALS_ERROR");
@@ -1285,8 +1950,13 @@ hb_string_T error_type_to_string(ERROR_T* error) {
     case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: return hb_string("STRICT_LOCALS_SPLAT_ARGUMENT_ERROR");
     case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: return hb_string("STRICT_LOCALS_MISSING_PARENTHESIS_ERROR");
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR");
+    case HERB_STATE_MISSING_PARENTHESIS_ERROR: return hb_string("HERB_STATE_MISSING_PARENTHESIS_ERROR");
+    case HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR: return hb_string("HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR");
+    case HERB_STATE_INVALID_PARAMETER_ERROR: return hb_string("HERB_STATE_INVALID_PARAMETER_ERROR");
+    case HERB_STATE_DUPLICATE_DECLARATION_ERROR: return hb_string("HERB_STATE_DUPLICATE_DECLARATION_ERROR");
     case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VOID_ELEMENT_CONTENT_ERROR");
     case DOT_NOTATION_CASING_ERROR: return hb_string("DOT_NOTATION_CASING_ERROR");
+    case TIMEOUT_ERROR: return hb_string("TIMEOUT_ERROR");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1306,15 +1976,25 @@ hb_string_T error_human_type(ERROR_T* error) {
     case MISSING_ERB_END_TAG_ERROR: return hb_string("MissingERBEndTagError");
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return hb_string("ERBMultipleBlocksInTagError");
     case ERB_CASE_WITH_CONDITIONS_ERROR: return hb_string("ERBCaseWithConditionsError");
+    case ERB_CASE_INLINE_PATTERN_MATCH_ERROR: return hb_string("ERBCaseInlinePatternMatchError");
     case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: return hb_string("ConditionalElementMultipleTagsError");
     case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: return hb_string("ConditionalElementConditionMismatchError");
+    case UNCLOSED_COMMENT_ERROR: return hb_string("UnclosedCommentError");
+    case NESTED_COMMENT_ERROR: return hb_string("NestedCommentError");
     case INVALID_COMMENT_CLOSING_TAG_ERROR: return hb_string("InvalidCommentClosingTagError");
     case OMITTED_CLOSING_TAG_ERROR: return hb_string("OmittedClosingTagError");
     case UNCLOSED_OPEN_TAG_ERROR: return hb_string("UnclosedOpenTagError");
     case UNCLOSED_CLOSE_TAG_ERROR: return hb_string("UnclosedCloseTagError");
+    case END_TAG_WITH_TRAILING_SOLIDUS_ERROR: return hb_string("EndTagWithTrailingSolidusError");
     case UNCLOSED_QUOTE_ERROR: return hb_string("UnclosedQuoteError");
     case MISSING_ATTRIBUTE_VALUE_ERROR: return hb_string("MissingAttributeValueError");
+    case MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR: return hb_string("MissingWhitespaceBetweenAttributesError");
+    case UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR: return hb_string("UnexpectedCharacterInAttributeNameError");
+    case UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR: return hb_string("UnexpectedCharacterInUnquotedAttributeValueError");
+    case UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR: return hb_string("UnexpectedEqualsSignBeforeAttributeNameError");
+    case UNEXPECTED_SOLIDUS_IN_TAG_ERROR: return hb_string("UnexpectedSolidusInTagError");
     case UNCLOSED_ERB_TAG_ERROR: return hb_string("UnclosedERBTagError");
+    case MALFORMED_ERB_CLOSING_TAG_ERROR: return hb_string("MalformedERBClosingTagError");
     case STRAY_ERB_CLOSING_TAG_ERROR: return hb_string("StrayERBClosingTagError");
     case NESTED_ERB_TAG_ERROR: return hb_string("NestedERBTagError");
     case RENDER_AMBIGUOUS_LOCALS_ERROR: return hb_string("RenderAmbiguousLocalsError");
@@ -1329,8 +2009,13 @@ hb_string_T error_human_type(ERROR_T* error) {
     case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: return hb_string("StrictLocalsSplatArgumentError");
     case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: return hb_string("StrictLocalsMissingParenthesisError");
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("StrictLocalsDuplicateDeclarationError");
+    case HERB_STATE_MISSING_PARENTHESIS_ERROR: return hb_string("HerbStateMissingParenthesisError");
+    case HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR: return hb_string("HerbStateNonCanonicalDirectiveError");
+    case HERB_STATE_INVALID_PARAMETER_ERROR: return hb_string("HerbStateInvalidParameterError");
+    case HERB_STATE_DUPLICATE_DECLARATION_ERROR: return hb_string("HerbStateDuplicateDeclarationError");
     case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VoidElementContentError");
     case DOT_NOTATION_CASING_ERROR: return hb_string("DotNotationCasingError");
+    case TIMEOUT_ERROR: return hb_string("TimeoutError");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1345,9 +2030,9 @@ void error_free_base_error(ERROR_T* error, hb_allocator_T* allocator) {
 }
 
 static void error_free_unexpected_error(UNEXPECTED_ERROR_T* unexpected_error, hb_allocator_T* allocator) {
-  if (unexpected_error->description.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->description.data); }
-  if (unexpected_error->expected.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->expected.data); }
-  if (unexpected_error->found.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->found.data); }
+  if (!hb_string_is_empty(unexpected_error->description)) { hb_allocator_dealloc(allocator, unexpected_error->description.data); }
+  if (!hb_string_is_empty(unexpected_error->expected)) { hb_allocator_dealloc(allocator, unexpected_error->expected.data); }
+  if (!hb_string_is_empty(unexpected_error->found)) { hb_allocator_dealloc(allocator, unexpected_error->found.data); }
 
   error_free_base_error(&unexpected_error->base, allocator);
 }
@@ -1380,8 +2065,8 @@ static void error_free_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR_T* tag_
 
 static void error_free_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error, hb_allocator_T* allocator) {
   if (void_element_closing_tag_error->tag_name != NULL) { token_free(void_element_closing_tag_error->tag_name, allocator); }
-  if (void_element_closing_tag_error->expected.data != NULL) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->expected.data); }
-  if (void_element_closing_tag_error->found.data != NULL) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->found.data); }
+  if (!hb_string_is_empty(void_element_closing_tag_error->expected)) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->expected.data); }
+  if (!hb_string_is_empty(void_element_closing_tag_error->found)) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->found.data); }
 
   error_free_base_error(&void_element_closing_tag_error->base, allocator);
 }
@@ -1393,21 +2078,21 @@ static void error_free_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* unclosed
 }
 
 static void error_free_ruby_parse_error(RUBY_PARSE_ERROR_T* ruby_parse_error, hb_allocator_T* allocator) {
-  if (ruby_parse_error->error_message.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->error_message.data); }
-  if (ruby_parse_error->diagnostic_id.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->diagnostic_id.data); }
-  if (ruby_parse_error->level.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->level.data); }
+  if (!hb_string_is_empty(ruby_parse_error->error_message)) { hb_allocator_dealloc(allocator, ruby_parse_error->error_message.data); }
+  if (!hb_string_is_empty(ruby_parse_error->diagnostic_id)) { hb_allocator_dealloc(allocator, ruby_parse_error->diagnostic_id.data); }
+  if (!hb_string_is_empty(ruby_parse_error->level)) { hb_allocator_dealloc(allocator, ruby_parse_error->level.data); }
 
   error_free_base_error(&ruby_parse_error->base, allocator);
 }
 
 static void error_free_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error, hb_allocator_T* allocator) {
-  if (erb_control_flow_scope_error->keyword.data != NULL) { hb_allocator_dealloc(allocator, erb_control_flow_scope_error->keyword.data); }
+  if (!hb_string_is_empty(erb_control_flow_scope_error->keyword)) { hb_allocator_dealloc(allocator, erb_control_flow_scope_error->keyword.data); }
 
   error_free_base_error(&erb_control_flow_scope_error->base, allocator);
 }
 
 static void error_free_missing_erb_end_tag_error(MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error, hb_allocator_T* allocator) {
-  if (missing_erb_end_tag_error->keyword.data != NULL) { hb_allocator_dealloc(allocator, missing_erb_end_tag_error->keyword.data); }
+  if (!hb_string_is_empty(missing_erb_end_tag_error->keyword)) { hb_allocator_dealloc(allocator, missing_erb_end_tag_error->keyword.data); }
 
   error_free_base_error(&missing_erb_end_tag_error->base, allocator);
 }
@@ -1424,6 +2109,12 @@ static void error_free_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_E
   error_free_base_error(&erb_case_with_conditions_error->base, allocator);
 }
 
+static void error_free_erb_case_inline_pattern_match_error(ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T* erb_case_inline_pattern_match_error, hb_allocator_T* allocator) {
+  /* no ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T specific fields to free up */
+
+  error_free_base_error(&erb_case_inline_pattern_match_error->base, allocator);
+}
+
 static void error_free_conditional_element_multiple_tags_error(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error, hb_allocator_T* allocator) {
   // size_t is part of struct
   // size_t is part of struct
@@ -1432,17 +2123,30 @@ static void error_free_conditional_element_multiple_tags_error(CONDITIONAL_ELEME
 }
 
 static void error_free_conditional_element_condition_mismatch_error(CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error, hb_allocator_T* allocator) {
-  if (conditional_element_condition_mismatch_error->tag_name.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->tag_name.data); }
-  if (conditional_element_condition_mismatch_error->open_condition.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->open_condition.data); }
+  if (!hb_string_is_empty(conditional_element_condition_mismatch_error->tag_name)) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->tag_name.data); }
+  if (!hb_string_is_empty(conditional_element_condition_mismatch_error->open_condition)) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->open_condition.data); }
   // size_t is part of struct
   // size_t is part of struct
-  if (conditional_element_condition_mismatch_error->close_condition.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->close_condition.data); }
+  if (!hb_string_is_empty(conditional_element_condition_mismatch_error->close_condition)) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->close_condition.data); }
   // size_t is part of struct
   // size_t is part of struct
 
   error_free_base_error(&conditional_element_condition_mismatch_error->base, allocator);
 }
 
+static void error_free_unclosed_comment_error(UNCLOSED_COMMENT_ERROR_T* unclosed_comment_error, hb_allocator_T* allocator) {
+  if (unclosed_comment_error->comment_start != NULL) { token_free(unclosed_comment_error->comment_start, allocator); }
+
+  error_free_base_error(&unclosed_comment_error->base, allocator);
+}
+
+static void error_free_nested_comment_error(NESTED_COMMENT_ERROR_T* nested_comment_error, hb_allocator_T* allocator) {
+  if (nested_comment_error->comment_start != NULL) { token_free(nested_comment_error->comment_start, allocator); }
+  if (nested_comment_error->nested_start != NULL) { token_free(nested_comment_error->nested_start, allocator); }
+
+  error_free_base_error(&nested_comment_error->base, allocator);
+}
+
 static void error_free_invalid_comment_closing_tag_error(INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error, hb_allocator_T* allocator) {
   if (invalid_comment_closing_tag_error->closing_tag != NULL) { token_free(invalid_comment_closing_tag_error->closing_tag, allocator); }
 
@@ -1468,6 +2172,12 @@ static void error_free_unclosed_close_tag_error(UNCLOSED_CLOSE_TAG_ERROR_T* uncl
   error_free_base_error(&unclosed_close_tag_error->base, allocator);
 }
 
+static void error_free_end_tag_with_trailing_solidus_error(END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T* end_tag_with_trailing_solidus_error, hb_allocator_T* allocator) {
+  if (end_tag_with_trailing_solidus_error->tag_name != NULL) { token_free(end_tag_with_trailing_solidus_error->tag_name, allocator); }
+
+  error_free_base_error(&end_tag_with_trailing_solidus_error->base, allocator);
+}
+
 static void error_free_unclosed_quote_error(UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error, hb_allocator_T* allocator) {
   if (unclosed_quote_error->opening_quote != NULL) { token_free(unclosed_quote_error->opening_quote, allocator); }
 
@@ -1475,17 +2185,54 @@ static void error_free_unclosed_quote_error(UNCLOSED_QUOTE_ERROR_T* unclosed_quo
 }
 
 static void error_free_missing_attribute_value_error(MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error, hb_allocator_T* allocator) {
-  if (missing_attribute_value_error->attribute_name.data != NULL) { hb_allocator_dealloc(allocator, missing_attribute_value_error->attribute_name.data); }
+  if (!hb_string_is_empty(missing_attribute_value_error->attribute_name)) { hb_allocator_dealloc(allocator, missing_attribute_value_error->attribute_name.data); }
 
   error_free_base_error(&missing_attribute_value_error->base, allocator);
 }
 
+static void error_free_missing_whitespace_between_attributes_error(MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T* missing_whitespace_between_attributes_error, hb_allocator_T* allocator) {
+  if (missing_whitespace_between_attributes_error->found != NULL) { token_free(missing_whitespace_between_attributes_error->found, allocator); }
+
+  error_free_base_error(&missing_whitespace_between_attributes_error->base, allocator);
+}
+
+static void error_free_unexpected_character_in_attribute_name_error(UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T* unexpected_character_in_attribute_name_error, hb_allocator_T* allocator) {
+  if (unexpected_character_in_attribute_name_error->character != NULL) { token_free(unexpected_character_in_attribute_name_error->character, allocator); }
+
+  error_free_base_error(&unexpected_character_in_attribute_name_error->base, allocator);
+}
+
+static void error_free_unexpected_character_in_unquoted_attribute_value_error(UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T* unexpected_character_in_unquoted_attribute_value_error, hb_allocator_T* allocator) {
+  if (unexpected_character_in_unquoted_attribute_value_error->character != NULL) { token_free(unexpected_character_in_unquoted_attribute_value_error->character, allocator); }
+
+  error_free_base_error(&unexpected_character_in_unquoted_attribute_value_error->base, allocator);
+}
+
+static void error_free_unexpected_equals_sign_before_attribute_name_error(UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T* unexpected_equals_sign_before_attribute_name_error, hb_allocator_T* allocator) {
+  if (unexpected_equals_sign_before_attribute_name_error->equals != NULL) { token_free(unexpected_equals_sign_before_attribute_name_error->equals, allocator); }
+
+  error_free_base_error(&unexpected_equals_sign_before_attribute_name_error->base, allocator);
+}
+
+static void error_free_unexpected_solidus_in_tag_error(UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T* unexpected_solidus_in_tag_error, hb_allocator_T* allocator) {
+  if (unexpected_solidus_in_tag_error->solidus != NULL) { token_free(unexpected_solidus_in_tag_error->solidus, allocator); }
+
+  error_free_base_error(&unexpected_solidus_in_tag_error->base, allocator);
+}
+
 static void error_free_unclosed_erb_tag_error(UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error, hb_allocator_T* allocator) {
   if (unclosed_erb_tag_error->opening_tag != NULL) { token_free(unclosed_erb_tag_error->opening_tag, allocator); }
 
   error_free_base_error(&unclosed_erb_tag_error->base, allocator);
 }
 
+static void error_free_malformed_erb_closing_tag_error(MALFORMED_ERB_CLOSING_TAG_ERROR_T* malformed_erb_closing_tag_error, hb_allocator_T* allocator) {
+  if (malformed_erb_closing_tag_error->opening_tag != NULL) { token_free(malformed_erb_closing_tag_error->opening_tag, allocator); }
+  if (malformed_erb_closing_tag_error->closing_tag != NULL) { token_free(malformed_erb_closing_tag_error->closing_tag, allocator); }
+
+  error_free_base_error(&malformed_erb_closing_tag_error->base, allocator);
+}
+
 static void error_free_stray_erb_closing_tag_error(STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error, hb_allocator_T* allocator) {
   /* no STRAY_ERB_CLOSING_TAG_ERROR_T specific fields to free up */
 
@@ -1501,14 +2248,14 @@ static void error_free_nested_erb_tag_error(NESTED_ERB_TAG_ERROR_T* nested_erb_t
 }
 
 static void error_free_render_ambiguous_locals_error(RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error, hb_allocator_T* allocator) {
-  if (render_ambiguous_locals_error->partial.data != NULL) { hb_allocator_dealloc(allocator, render_ambiguous_locals_error->partial.data); }
+  if (!hb_string_is_empty(render_ambiguous_locals_error->partial)) { hb_allocator_dealloc(allocator, render_ambiguous_locals_error->partial.data); }
 
   error_free_base_error(&render_ambiguous_locals_error->base, allocator);
 }
 
 static void error_free_render_missing_locals_error(RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error, hb_allocator_T* allocator) {
-  if (render_missing_locals_error->partial.data != NULL) { hb_allocator_dealloc(allocator, render_missing_locals_error->partial.data); }
-  if (render_missing_locals_error->keywords.data != NULL) { hb_allocator_dealloc(allocator, render_missing_locals_error->keywords.data); }
+  if (!hb_string_is_empty(render_missing_locals_error->partial)) { hb_allocator_dealloc(allocator, render_missing_locals_error->partial.data); }
+  if (!hb_string_is_empty(render_missing_locals_error->keywords)) { hb_allocator_dealloc(allocator, render_missing_locals_error->keywords.data); }
 
   error_free_base_error(&render_missing_locals_error->base, allocator);
 }
@@ -1520,14 +2267,14 @@ static void error_free_render_no_arguments_error(RENDER_NO_ARGUMENTS_ERROR_T* re
 }
 
 static void error_free_render_conflicting_partial_error(RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error, hb_allocator_T* allocator) {
-  if (render_conflicting_partial_error->positional_partial.data != NULL) { hb_allocator_dealloc(allocator, render_conflicting_partial_error->positional_partial.data); }
-  if (render_conflicting_partial_error->keyword_partial.data != NULL) { hb_allocator_dealloc(allocator, render_conflicting_partial_error->keyword_partial.data); }
+  if (!hb_string_is_empty(render_conflicting_partial_error->positional_partial)) { hb_allocator_dealloc(allocator, render_conflicting_partial_error->positional_partial.data); }
+  if (!hb_string_is_empty(render_conflicting_partial_error->keyword_partial)) { hb_allocator_dealloc(allocator, render_conflicting_partial_error->keyword_partial.data); }
 
   error_free_base_error(&render_conflicting_partial_error->base, allocator);
 }
 
 static void error_free_render_invalid_as_option_error(RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error, hb_allocator_T* allocator) {
-  if (render_invalid_as_option_error->as_value.data != NULL) { hb_allocator_dealloc(allocator, render_invalid_as_option_error->as_value.data); }
+  if (!hb_string_is_empty(render_invalid_as_option_error->as_value)) { hb_allocator_dealloc(allocator, render_invalid_as_option_error->as_value.data); }
 
   error_free_base_error(&render_invalid_as_option_error->base, allocator);
 }
@@ -1539,31 +2286,31 @@ static void error_free_render_object_and_collection_error(RENDER_OBJECT_AND_COLL
 }
 
 static void error_free_render_layout_without_block_error(RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error, hb_allocator_T* allocator) {
-  if (render_layout_without_block_error->layout.data != NULL) { hb_allocator_dealloc(allocator, render_layout_without_block_error->layout.data); }
+  if (!hb_string_is_empty(render_layout_without_block_error->layout)) { hb_allocator_dealloc(allocator, render_layout_without_block_error->layout.data); }
 
   error_free_base_error(&render_layout_without_block_error->base, allocator);
 }
 
 static void error_free_strict_locals_positional_argument_error(STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error, hb_allocator_T* allocator) {
-  if (strict_locals_positional_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_positional_argument_error->name.data); }
+  if (!hb_string_is_empty(strict_locals_positional_argument_error->name)) { hb_allocator_dealloc(allocator, strict_locals_positional_argument_error->name.data); }
 
   error_free_base_error(&strict_locals_positional_argument_error->base, allocator);
 }
 
 static void error_free_strict_locals_block_argument_error(STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error, hb_allocator_T* allocator) {
-  if (strict_locals_block_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_block_argument_error->name.data); }
+  if (!hb_string_is_empty(strict_locals_block_argument_error->name)) { hb_allocator_dealloc(allocator, strict_locals_block_argument_error->name.data); }
 
   error_free_base_error(&strict_locals_block_argument_error->base, allocator);
 }
 
 static void error_free_strict_locals_splat_argument_error(STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error, hb_allocator_T* allocator) {
-  if (strict_locals_splat_argument_error->name.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_splat_argument_error->name.data); }
+  if (!hb_string_is_empty(strict_locals_splat_argument_error->name)) { hb_allocator_dealloc(allocator, strict_locals_splat_argument_error->name.data); }
 
   error_free_base_error(&strict_locals_splat_argument_error->base, allocator);
 }
 
 static void error_free_strict_locals_missing_parenthesis_error(STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error, hb_allocator_T* allocator) {
-  if (strict_locals_missing_parenthesis_error->rest.data != NULL) { hb_allocator_dealloc(allocator, strict_locals_missing_parenthesis_error->rest.data); }
+  if (!hb_string_is_empty(strict_locals_missing_parenthesis_error->rest)) { hb_allocator_dealloc(allocator, strict_locals_missing_parenthesis_error->rest.data); }
 
   error_free_base_error(&strict_locals_missing_parenthesis_error->base, allocator);
 }
@@ -1574,10 +2321,35 @@ static void error_free_strict_locals_duplicate_declaration_error(STRICT_LOCALS_D
   error_free_base_error(&strict_locals_duplicate_declaration_error->base, allocator);
 }
 
+static void error_free_herb_state_missing_parenthesis_error(HERB_STATE_MISSING_PARENTHESIS_ERROR_T* herb_state_missing_parenthesis_error, hb_allocator_T* allocator) {
+  if (!hb_string_is_empty(herb_state_missing_parenthesis_error->rest)) { hb_allocator_dealloc(allocator, herb_state_missing_parenthesis_error->rest.data); }
+
+  error_free_base_error(&herb_state_missing_parenthesis_error->base, allocator);
+}
+
+static void error_free_herb_state_non_canonical_directive_error(HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T* herb_state_non_canonical_directive_error, hb_allocator_T* allocator) {
+  if (!hb_string_is_empty(herb_state_non_canonical_directive_error->found)) { hb_allocator_dealloc(allocator, herb_state_non_canonical_directive_error->found.data); }
+  if (!hb_string_is_empty(herb_state_non_canonical_directive_error->expected)) { hb_allocator_dealloc(allocator, herb_state_non_canonical_directive_error->expected.data); }
+
+  error_free_base_error(&herb_state_non_canonical_directive_error->base, allocator);
+}
+
+static void error_free_herb_state_invalid_parameter_error(HERB_STATE_INVALID_PARAMETER_ERROR_T* herb_state_invalid_parameter_error, hb_allocator_T* allocator) {
+  if (!hb_string_is_empty(herb_state_invalid_parameter_error->parameter)) { hb_allocator_dealloc(allocator, herb_state_invalid_parameter_error->parameter.data); }
+
+  error_free_base_error(&herb_state_invalid_parameter_error->base, allocator);
+}
+
+static void error_free_herb_state_duplicate_declaration_error(HERB_STATE_DUPLICATE_DECLARATION_ERROR_T* herb_state_duplicate_declaration_error, hb_allocator_T* allocator) {
+  /* no HERB_STATE_DUPLICATE_DECLARATION_ERROR_T specific fields to free up */
+
+  error_free_base_error(&herb_state_duplicate_declaration_error->base, allocator);
+}
+
 static void error_free_void_element_content_error(VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error, hb_allocator_T* allocator) {
   if (void_element_content_error->tag_name != NULL) { token_free(void_element_content_error->tag_name, allocator); }
-  if (void_element_content_error->helper_name.data != NULL) { hb_allocator_dealloc(allocator, void_element_content_error->helper_name.data); }
-  if (void_element_content_error->content_type.data != NULL) { hb_allocator_dealloc(allocator, void_element_content_error->content_type.data); }
+  if (!hb_string_is_empty(void_element_content_error->helper_name)) { hb_allocator_dealloc(allocator, void_element_content_error->helper_name.data); }
+  if (!hb_string_is_empty(void_element_content_error->content_type)) { hb_allocator_dealloc(allocator, void_element_content_error->content_type.data); }
 
   error_free_base_error(&void_element_content_error->base, allocator);
 }
@@ -1588,6 +2360,12 @@ static void error_free_dot_notation_casing_error(DOT_NOTATION_CASING_ERROR_T* do
   error_free_base_error(&dot_notation_casing_error->base, allocator);
 }
 
+static void error_free_timeout_error(TIMEOUT_ERROR_T* timeout_error, hb_allocator_T* allocator) {
+  // size_t is part of struct
+
+  error_free_base_error(&timeout_error->base, allocator);
+}
+
 void error_free(ERROR_T* error, hb_allocator_T* allocator) {
   if (!error) { return; }
 
@@ -1604,15 +2382,25 @@ void error_free(ERROR_T* error, hb_allocator_T* allocator) {
     case MISSING_ERB_END_TAG_ERROR: error_free_missing_erb_end_tag_error((MISSING_ERB_END_TAG_ERROR_T*) error, allocator); break;
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_free_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, allocator); break;
     case ERB_CASE_WITH_CONDITIONS_ERROR: error_free_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error, allocator); break;
+    case ERB_CASE_INLINE_PATTERN_MATCH_ERROR: error_free_erb_case_inline_pattern_match_error((ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T*) error, allocator); break;
     case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: error_free_conditional_element_multiple_tags_error((CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T*) error, allocator); break;
     case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: error_free_conditional_element_condition_mismatch_error((CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T*) error, allocator); break;
+    case UNCLOSED_COMMENT_ERROR: error_free_unclosed_comment_error((UNCLOSED_COMMENT_ERROR_T*) error, allocator); break;
+    case NESTED_COMMENT_ERROR: error_free_nested_comment_error((NESTED_COMMENT_ERROR_T*) error, allocator); break;
     case INVALID_COMMENT_CLOSING_TAG_ERROR: error_free_invalid_comment_closing_tag_error((INVALID_COMMENT_CLOSING_TAG_ERROR_T*) error, allocator); break;
     case OMITTED_CLOSING_TAG_ERROR: error_free_omitted_closing_tag_error((OMITTED_CLOSING_TAG_ERROR_T*) error, allocator); break;
     case UNCLOSED_OPEN_TAG_ERROR: error_free_unclosed_open_tag_error((UNCLOSED_OPEN_TAG_ERROR_T*) error, allocator); break;
     case UNCLOSED_CLOSE_TAG_ERROR: error_free_unclosed_close_tag_error((UNCLOSED_CLOSE_TAG_ERROR_T*) error, allocator); break;
+    case END_TAG_WITH_TRAILING_SOLIDUS_ERROR: error_free_end_tag_with_trailing_solidus_error((END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T*) error, allocator); break;
     case UNCLOSED_QUOTE_ERROR: error_free_unclosed_quote_error((UNCLOSED_QUOTE_ERROR_T*) error, allocator); break;
     case MISSING_ATTRIBUTE_VALUE_ERROR: error_free_missing_attribute_value_error((MISSING_ATTRIBUTE_VALUE_ERROR_T*) error, allocator); break;
+    case MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR: error_free_missing_whitespace_between_attributes_error((MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T*) error, allocator); break;
+    case UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR: error_free_unexpected_character_in_attribute_name_error((UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T*) error, allocator); break;
+    case UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR: error_free_unexpected_character_in_unquoted_attribute_value_error((UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T*) error, allocator); break;
+    case UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR: error_free_unexpected_equals_sign_before_attribute_name_error((UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T*) error, allocator); break;
+    case UNEXPECTED_SOLIDUS_IN_TAG_ERROR: error_free_unexpected_solidus_in_tag_error((UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T*) error, allocator); break;
     case UNCLOSED_ERB_TAG_ERROR: error_free_unclosed_erb_tag_error((UNCLOSED_ERB_TAG_ERROR_T*) error, allocator); break;
+    case MALFORMED_ERB_CLOSING_TAG_ERROR: error_free_malformed_erb_closing_tag_error((MALFORMED_ERB_CLOSING_TAG_ERROR_T*) error, allocator); break;
     case STRAY_ERB_CLOSING_TAG_ERROR: error_free_stray_erb_closing_tag_error((STRAY_ERB_CLOSING_TAG_ERROR_T*) error, allocator); break;
     case NESTED_ERB_TAG_ERROR: error_free_nested_erb_tag_error((NESTED_ERB_TAG_ERROR_T*) error, allocator); break;
     case RENDER_AMBIGUOUS_LOCALS_ERROR: error_free_render_ambiguous_locals_error((RENDER_AMBIGUOUS_LOCALS_ERROR_T*) error, allocator); break;
@@ -1627,8 +2415,13 @@ void error_free(ERROR_T* error, hb_allocator_T* allocator) {
     case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: error_free_strict_locals_splat_argument_error((STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T*) error, allocator); break;
     case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: error_free_strict_locals_missing_parenthesis_error((STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T*) error, allocator); break;
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_free_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, allocator); break;
+    case HERB_STATE_MISSING_PARENTHESIS_ERROR: error_free_herb_state_missing_parenthesis_error((HERB_STATE_MISSING_PARENTHESIS_ERROR_T*) error, allocator); break;
+    case HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR: error_free_herb_state_non_canonical_directive_error((HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T*) error, allocator); break;
+    case HERB_STATE_INVALID_PARAMETER_ERROR: error_free_herb_state_invalid_parameter_error((HERB_STATE_INVALID_PARAMETER_ERROR_T*) error, allocator); break;
+    case HERB_STATE_DUPLICATE_DECLARATION_ERROR: error_free_herb_state_duplicate_declaration_error((HERB_STATE_DUPLICATE_DECLARATION_ERROR_T*) error, allocator); break;
     case VOID_ELEMENT_CONTENT_ERROR: error_free_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, allocator); break;
     case DOT_NOTATION_CASING_ERROR: error_free_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, allocator); break;
+    case TIMEOUT_ERROR: error_free_timeout_error((TIMEOUT_ERROR_T*) error, allocator); break;
   }
 }
 
@@ -1852,6 +2645,19 @@ static void error_pretty_print_erb_case_with_conditions_error(ERB_CASE_WITH_COND
   pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_erb_case_inline_pattern_match_error(ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_conditional_element_multiple_tags_error(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -1887,6 +2693,35 @@ static void error_pretty_print_conditional_element_condition_mismatch_error(COND
   pretty_print_size_t_property(error->close_column, hb_string("close_column"), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_unclosed_comment_error(UNCLOSED_COMMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->comment_start, hb_string("comment_start"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_nested_comment_error(NESTED_COMMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->comment_start, hb_string("comment_start"), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->nested_start, hb_string("nested_start"), indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_invalid_comment_closing_tag_error(INVALID_COMMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -1944,6 +2779,20 @@ static void error_pretty_print_unclosed_close_tag_error(UNCLOSED_CLOSE_TAG_ERROR
   pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_end_tag_with_trailing_solidus_error(END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_unclosed_quote_error(UNCLOSED_QUOTE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -1972,6 +2821,76 @@ static void error_pretty_print_missing_attribute_value_error(MISSING_ATTRIBUTE_V
   pretty_print_quoted_property(hb_string("attribute_name"), error->attribute_name, indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_missing_whitespace_between_attributes_error(MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->found, hb_string("found"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unexpected_character_in_attribute_name_error(UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->character, hb_string("character"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unexpected_character_in_unquoted_attribute_value_error(UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->character, hb_string("character"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unexpected_equals_sign_before_attribute_name_error(UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->equals, hb_string("equals"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unexpected_solidus_in_tag_error(UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->solidus, hb_string("solidus"), indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_unclosed_erb_tag_error(UNCLOSED_ERB_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -1986,6 +2905,21 @@ static void error_pretty_print_unclosed_erb_tag_error(UNCLOSED_ERB_TAG_ERROR_T*
   pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_malformed_erb_closing_tag_error(MALFORMED_ERB_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_stray_erb_closing_tag_error(STRAY_ERB_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -2182,6 +3116,62 @@ static void error_pretty_print_strict_locals_duplicate_declaration_error(STRICT_
   pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_herb_state_missing_parenthesis_error(HERB_STATE_MISSING_PARENTHESIS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("rest"), error->rest, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_herb_state_non_canonical_directive_error(HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("found"), error->found, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("expected"), error->expected, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_herb_state_invalid_parameter_error(HERB_STATE_INVALID_PARAMETER_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("parameter"), error->parameter, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_herb_state_duplicate_declaration_error(HERB_STATE_DUPLICATE_DECLARATION_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
+}
+
 static void error_pretty_print_void_element_content_error(VOID_ELEMENT_CONTENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -2212,6 +3202,20 @@ static void error_pretty_print_dot_notation_casing_error(DOT_NOTATION_CASING_ERR
   pretty_print_token_property(error->segment, hb_string("segment"), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_timeout_error(TIMEOUT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->timeout_ms, hb_string("timeout_ms"), indent, relative_indent, true, buffer);
+}
+
 void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -2228,15 +3232,25 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case MISSING_ERB_END_TAG_ERROR: error_pretty_print_missing_erb_end_tag_error((MISSING_ERB_END_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_pretty_print_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_CASE_WITH_CONDITIONS_ERROR: error_pretty_print_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case ERB_CASE_INLINE_PATTERN_MATCH_ERROR: error_pretty_print_erb_case_inline_pattern_match_error((ERB_CASE_INLINE_PATTERN_MATCH_ERROR_T*) error, indent, relative_indent, buffer); break;
     case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: error_pretty_print_conditional_element_multiple_tags_error((CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T*) error, indent, relative_indent, buffer); break;
     case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: error_pretty_print_conditional_element_condition_mismatch_error((CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNCLOSED_COMMENT_ERROR: error_pretty_print_unclosed_comment_error((UNCLOSED_COMMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case NESTED_COMMENT_ERROR: error_pretty_print_nested_comment_error((NESTED_COMMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     case INVALID_COMMENT_CLOSING_TAG_ERROR: error_pretty_print_invalid_comment_closing_tag_error((INVALID_COMMENT_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case OMITTED_CLOSING_TAG_ERROR: error_pretty_print_omitted_closing_tag_error((OMITTED_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_OPEN_TAG_ERROR: error_pretty_print_unclosed_open_tag_error((UNCLOSED_OPEN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_CLOSE_TAG_ERROR: error_pretty_print_unclosed_close_tag_error((UNCLOSED_CLOSE_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case END_TAG_WITH_TRAILING_SOLIDUS_ERROR: error_pretty_print_end_tag_with_trailing_solidus_error((END_TAG_WITH_TRAILING_SOLIDUS_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_QUOTE_ERROR: error_pretty_print_unclosed_quote_error((UNCLOSED_QUOTE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case MISSING_ATTRIBUTE_VALUE_ERROR: error_pretty_print_missing_attribute_value_error((MISSING_ATTRIBUTE_VALUE_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR: error_pretty_print_missing_whitespace_between_attributes_error((MISSING_WHITESPACE_BETWEEN_ATTRIBUTES_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR: error_pretty_print_unexpected_character_in_attribute_name_error((UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR: error_pretty_print_unexpected_character_in_unquoted_attribute_value_error((UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR: error_pretty_print_unexpected_equals_sign_before_attribute_name_error((UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNEXPECTED_SOLIDUS_IN_TAG_ERROR: error_pretty_print_unexpected_solidus_in_tag_error((UNEXPECTED_SOLIDUS_IN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_ERB_TAG_ERROR: error_pretty_print_unclosed_erb_tag_error((UNCLOSED_ERB_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case MALFORMED_ERB_CLOSING_TAG_ERROR: error_pretty_print_malformed_erb_closing_tag_error((MALFORMED_ERB_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case STRAY_ERB_CLOSING_TAG_ERROR: error_pretty_print_stray_erb_closing_tag_error((STRAY_ERB_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case NESTED_ERB_TAG_ERROR: error_pretty_print_nested_erb_tag_error((NESTED_ERB_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case RENDER_AMBIGUOUS_LOCALS_ERROR: error_pretty_print_render_ambiguous_locals_error((RENDER_AMBIGUOUS_LOCALS_ERROR_T*) error, indent, relative_indent, buffer); break;
@@ -2251,8 +3265,13 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: error_pretty_print_strict_locals_splat_argument_error((STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: error_pretty_print_strict_locals_missing_parenthesis_error((STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T*) error, indent, relative_indent, buffer); break;
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_pretty_print_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case HERB_STATE_MISSING_PARENTHESIS_ERROR: error_pretty_print_herb_state_missing_parenthesis_error((HERB_STATE_MISSING_PARENTHESIS_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR: error_pretty_print_herb_state_non_canonical_directive_error((HERB_STATE_NON_CANONICAL_DIRECTIVE_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case HERB_STATE_INVALID_PARAMETER_ERROR: error_pretty_print_herb_state_invalid_parameter_error((HERB_STATE_INVALID_PARAMETER_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case HERB_STATE_DUPLICATE_DECLARATION_ERROR: error_pretty_print_herb_state_duplicate_declaration_error((HERB_STATE_DUPLICATE_DECLARATION_ERROR_T*) error, indent, relative_indent, buffer); break;
     case VOID_ELEMENT_CONTENT_ERROR: error_pretty_print_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     case DOT_NOTATION_CASING_ERROR: error_pretty_print_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case TIMEOUT_ERROR: error_pretty_print_timeout_error((TIMEOUT_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }