@herb-tools/node 0.7.5 → 0.8.0

package/extension/libherb/include/util/hb_string.h

@@ -0,0 +1,29 @@
+#ifndef HERB_STRING_H
+#define HERB_STRING_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hb_arena.h"
+
+typedef struct HB_STRING_STRUCT {
+  char* data;
+  uint32_t length;
+} hb_string_T;
+
+hb_string_T hb_string(const char* null_terminated_c_string);
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
+bool hb_string_equals(hb_string_T a, hb_string_T b);
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
+bool hb_string_is_empty(hb_string_T string);
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length);
+
+hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to);
+
+char* hb_string_to_c_string_using_malloc(hb_string_T string);
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
+
+#endif

package/extension/libherb/include/util/hb_system.h

@@ -0,0 +1,9 @@
+#ifndef HERB_SYSTEM_H
+#define HERB_SYSTEM_H
+
+#include <stddef.h>
+
+void* hb_system_allocate_memory(size_t size);
+void hb_system_free_memory(void* ptr, size_t size);
+
+#endif

package/extension/libherb/include/util.h

@@ -1,25 +1,14 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
-int is_whitespace(int character);
 int is_newline(int character);
 
-int count_in_string(const char* string, char character);
-int count_newlines(const char* string);
-
-char* replace_char(char* string, char find, char replace);
-char* escape_newlines(const char* input);
-char* quoted_string(const char* input);
-char* wrap_string(const char* input, char character);
-
-bool string_blank(const char* input);
-bool string_present(const char* input);
-
+hb_string_T escape_newlines(hb_string_T input);
+hb_string_T quoted_string(hb_string_T input);
 char* herb_strdup(const char* s);
 
-char* size_t_to_string(size_t value);
-
 #endif

package/extension/libherb/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.5"
+#define HERB_VERSION "0.8.0"
 
 #endif

package/extension/libherb/include/visitor.h

@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);

package/extension/libherb/io.c

@@ -1,5 +1,5 @@
 #include "include/io.h"
-#include "include/buffer.h"
+#include "include/util/hb_buffer.h"
 
 #include <errno.h>
 #include <stdio.h>
@@ -8,6 +8,8 @@
 #define FILE_READ_CHUNK 4096
 
 char* herb_read_file(const char* filename) {
+  if (!filename) { return NULL; }
+
   FILE* fp = fopen(filename, "rb");
 
   if (fp == NULL) {
@@ -15,16 +17,17 @@ char* herb_read_file(const char* filename) {
     exit(1);
   }
 
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 4096);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;
 
   while ((bytes_read = fread(chunk, 1, FILE_READ_CHUNK, fp)) > 0) {
-    buffer_append_with_length(&buffer, chunk, bytes_read);
+    hb_buffer_append_with_length(&buffer, chunk, bytes_read);
   }
 
   fclose(fp);
 
-  return buffer_value(&buffer);
+  return hb_buffer_value(&buffer);
 }

package/extension/libherb/lexer.c

@@ -1,24 +1,21 @@
-#include "include/buffer.h"
 #include "include/lexer_peek_helpers.h"
 #include "include/token.h"
 #include "include/utf8.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <string.h>
 
 #define LEXER_STALL_LIMIT 5
 
-static size_t lexer_sizeof(void) {
-  return sizeof(struct LEXER_STRUCT);
-}
-
 static bool lexer_eof(const lexer_T* lexer) {
   return lexer->current_character == '\0' || lexer->stalled;
 }
 
 static bool lexer_has_more_characters(const lexer_T* lexer) {
-  return lexer->current_position < lexer->source_length;
+  return lexer->current_position < lexer->source.length;
 }
 
 static bool lexer_stalled(lexer_T* lexer) {
@@ -34,17 +31,16 @@ static bool lexer_stalled(lexer_T* lexer) {
   return lexer->stalled;
 }
 
-lexer_T* lexer_init(const char* source) {
-  if (source == NULL) { source = ""; }
-
-  lexer_T* lexer = calloc(1, lexer_sizeof());
+void lexer_init(lexer_T* lexer, const char* source) {
+  if (source != NULL) {
+    lexer->source = hb_string(source);
+  } else {
+    lexer->source = hb_string("");
+  }
 
+  lexer->current_character = lexer->source.data[0];
   lexer->state = STATE_DATA;
 
-  lexer->source = source;
-  lexer->source_length = (uint32_t) strlen(source);
-  lexer->current_character = source[0];
-
   lexer->current_line = 1;
   lexer->current_column = 0;
   lexer->current_position = 0;
@@ -56,8 +52,6 @@ lexer_T* lexer_init(const char* source) {
   lexer->stall_counter = 0;
   lexer->last_position = 0;
   lexer->stalled = false;
-
-  return lexer;
 }
 
 token_T* lexer_error(lexer_T* lexer, const char* message) {
@@ -73,7 +67,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
     lexer->current_column
   );
 
-  return token_init(error_message, TOKEN_ERROR, lexer);
+  return token_init(hb_string(error_message), TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {
@@ -81,7 +75,7 @@ static void lexer_advance(lexer_T* lexer) {
     if (!is_newline(lexer->current_character)) { lexer->current_column++; }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 }
 
@@ -93,11 +87,11 @@ static void lexer_advance_utf8_bytes(lexer_T* lexer, int byte_count) {
 
     lexer->current_position += byte_count;
 
-    if (lexer->current_position >= lexer->source_length) {
-      lexer->current_position = lexer->source_length;
+    if (lexer->current_position >= lexer->source.length) {
+      lexer->current_position = lexer->source.length;
       lexer->current_character = '\0';
     } else {
-      lexer->current_character = lexer->source[lexer->current_position];
+      lexer->current_character = lexer->source.data[lexer->current_position];
     }
   }
 }
@@ -108,65 +102,50 @@ static void lexer_advance_by(lexer_T* lexer, const size_t count) {
   }
 }
 
-static token_T* lexer_advance_with(lexer_T* lexer, const char* value, const token_type_T type) {
-  lexer_advance_by(lexer, strlen(value));
+static token_T* lexer_advance_with(lexer_T* lexer, hb_string_T value, const token_type_T type) {
+  lexer_advance_by(lexer, value.length);
   return token_init(value, type, lexer);
 }
 
 static token_T* lexer_advance_with_next(lexer_T* lexer, size_t count, token_type_T type) {
-  char* collected = malloc(count + 1);
-  if (!collected) { return NULL; }
+  uint32_t start_position = lexer->current_position;
 
   for (size_t i = 0; i < count; i++) {
-    collected[i] = lexer->current_character;
     lexer_advance(lexer);
   }
 
-  collected[count] = '\0';
-
-  token_T* token = token_init(collected, type, lexer);
-  free(collected);
+  token_T* token = token_init(hb_string_range(lexer->source, start_position, lexer->current_position), type, lexer);
 
   return token;
 }
 
 static token_T* lexer_advance_current(lexer_T* lexer, const token_type_T type) {
-  return lexer_advance_with(lexer, (char[]) { lexer->current_character, '\0' }, type);
+  char buffer[2];
+  buffer[0] = lexer->current_character;
+  buffer[1] = '\0';
+
+  return lexer_advance_with(lexer, hb_string(buffer), type);
 }
 
 static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T type) {
-  int char_byte_length = utf8_sequence_length(lexer->source, lexer->current_position, lexer->source_length);
-
+  int char_byte_length = utf8_sequence_length(lexer->source.data, lexer->current_position, lexer->source.length);
   if (char_byte_length <= 1) { return lexer_advance_current(lexer, type); }
-
-  char* utf8_char = malloc(char_byte_length + 1);
-
-  if (!utf8_char) { return lexer_advance_current(lexer, type); }
+  uint32_t start_position = lexer->current_position;
 
   for (int i = 0; i < char_byte_length; i++) {
-    if (lexer->current_position + i >= lexer->source_length) {
-      free(utf8_char);
-      return lexer_advance_current(lexer, type);
-    }
-
-    utf8_char[i] = lexer->source[lexer->current_position + i];
+    if (lexer->current_position + i >= lexer->source.length) { return lexer_advance_current(lexer, type); }
   }
 
-  utf8_char[char_byte_length] = '\0';
-
   lexer_advance_utf8_bytes(lexer, char_byte_length);
 
-  token_T* token = token_init(utf8_char, type, lexer);
-
-  free(utf8_char);
+  token_T* token = token_init(hb_string_range(lexer->source, start_position, lexer->current_position), type, lexer);
 
   return token;
 }
 
-static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const token_type_T type) {
-  if (strncmp(lexer->source + lexer->current_position, value, strlen(value)) == 0) {
-    return lexer_advance_with(lexer, value, type);
-  }
+static token_T* lexer_match_and_advance(lexer_T* lexer, hb_string_T value, const token_type_T type) {
+  hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position);
+  if (hb_string_starts_with(remaining_source, value)) { return lexer_advance_with(lexer, value, type); }
 
   return NULL;
 }
@@ -174,35 +153,31 @@ static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const
 // ===== Specialized Parsers
 
 static token_T* lexer_parse_whitespace(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   while (isspace(lexer->current_character) && lexer->current_character != '\n' && lexer->current_character != '\r'
          && !lexer_eof(lexer)) {
-    buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
-  token_T* token = token_init(buffer.value, TOKEN_WHITESPACE, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_WHITESPACE, lexer);
 
   return token;
 }
 
 static token_T* lexer_parse_identifier(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   while ((isalnum(lexer->current_character) || lexer->current_character == '-' || lexer->current_character == '_'
           || lexer->current_character == ':')
          && !lexer_peek_for_html_comment_end(lexer, 0) && !lexer_eof(lexer)) {
 
-    buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
-  token_T* token = token_init(buffer.value, TOKEN_IDENTIFIER, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_IDENTIFIER, lexer);
 
   return token;
 }
@@ -210,7 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  const char* erb_patterns[] = { "<%==", "<%%=", "<%=", "<%#", "<%-", "<%%", "<%" };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -223,14 +199,18 @@ static token_T* lexer_parse_erb_open(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_erb_content(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  uint32_t start_position = lexer->current_position;
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
-      return token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
-    }
+      token_T* token = token_init(
+        hb_string_range(lexer->source, start_position, lexer->current_position),
+        TOKEN_ERROR,
+        lexer
+      ); // Handle unexpected EOF
 
-    buffer_append_char(&buffer, lexer->current_character);
+      return token;
+    }
 
     if (is_newline(lexer->current_character)) {
       lexer->current_line++;
@@ -240,14 +220,13 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
     }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 
   lexer->state = STATE_ERB_CLOSE;
 
-  token_T* token = token_init(buffer.value, TOKEN_ERB_CONTENT, lexer);
-
-  buffer_free(&buffer);
+  token_T* token =
+    token_init(hb_string_range(lexer->source, start_position, lexer->current_position), TOKEN_ERB_CONTENT, lexer);
 
   return token;
 }
@@ -255,17 +234,17 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
 static token_T* lexer_parse_erb_close(lexer_T* lexer) {
   lexer->state = STATE_DATA;
 
-  if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "%%>", TOKEN_ERB_END); }
-  if (lexer_peek_erb_equals_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "=%>", TOKEN_ERB_END); }
-  if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "-%>", TOKEN_ERB_END); }
+  if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("%%>"), TOKEN_ERB_END); }
+  if (lexer_peek_erb_equals_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("=%>"), TOKEN_ERB_END); }
+  if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, hb_string("-%>"), TOKEN_ERB_END); }
 
-  return lexer_advance_with(lexer, "%>", TOKEN_ERB_END);
+  return lexer_advance_with(lexer, hb_string("%>"), TOKEN_ERB_END);
 }
 
 // ===== Tokenizing Function
 
 token_T* lexer_next_token(lexer_T* lexer) {
-  if (lexer_eof(lexer)) { return token_init("", TOKEN_EOF, lexer); }
+  if (lexer_eof(lexer)) { return token_init(hb_string(""), TOKEN_EOF, lexer); }
   if (lexer_stalled(lexer)) { return lexer_error(lexer, "Lexer stalled after 5 iterations"); }
 
   if (lexer->state == STATE_ERB_CONTENT) { return lexer_parse_erb_content(lexer); }
@@ -302,33 +281,33 @@ token_T* lexer_next_token(lexer_T* lexer) {
       if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
-        return lexer_advance_with(lexer, "<!--", TOKEN_HTML_COMMENT_START);
+        return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);
       }
 
       if (lexer_peek_for_close_tag_start(lexer, 0)) {
-        return lexer_advance_with(lexer, "</", TOKEN_HTML_TAG_START_CLOSE);
+        return lexer_advance_with(lexer, hb_string("</"), TOKEN_HTML_TAG_START_CLOSE);
       }
 
       return lexer_advance_current(lexer, TOKEN_LT);
     }
 
     case '/': {
-      token_T* token = lexer_match_and_advance(lexer, "/>", TOKEN_HTML_TAG_SELF_CLOSE);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("/>"), TOKEN_HTML_TAG_SELF_CLOSE);
       return token ? token : lexer_advance_current(lexer, TOKEN_SLASH);
     }
 
     case '?': {
-      token_T* token = lexer_match_and_advance(lexer, "?>", TOKEN_XML_DECLARATION_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("?>"), TOKEN_XML_DECLARATION_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_CHARACTER);
     }
 
     case '-': {
-      token_T* token = lexer_match_and_advance(lexer, "-->", TOKEN_HTML_COMMENT_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("-->"), TOKEN_HTML_COMMENT_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_DASH);
     }
 
     case ']': {
-      token_T* token = lexer_match_and_advance(lexer, "]]>", TOKEN_CDATA_END);
+      token_T* token = lexer_match_and_advance(lexer, hb_string("]]>"), TOKEN_CDATA_END);
       return token ? token : lexer_advance_current(lexer, TOKEN_CHARACTER);
     }
 
@@ -354,9 +333,3 @@ token_T* lexer_next_token(lexer_T* lexer) {
     }
   }
 }
-
-void lexer_free(lexer_T* lexer) {
-  if (lexer == NULL) { return; }
-
-  free(lexer);
-}

package/extension/libherb/lexer.h

@@ -4,10 +4,8 @@
 #include "lexer_struct.h"
 #include "token_struct.h"
 
-lexer_T* lexer_init(const char* source);
+void lexer_init(lexer_T* lexer, const char* source);
 token_T* lexer_next_token(lexer_T* lexer);
 token_T* lexer_error(lexer_T* lexer, const char* message);
 
-void lexer_free(lexer_T* lexer);
-
 #endif

package/extension/libherb/lexer_peek_helpers.c

@@ -3,73 +3,71 @@
 #include "include/lexer_struct.h"
 #include "include/macros.h"
 #include "include/token.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 
-char lexer_backtrack(const lexer_T* lexer, const int offset) {
-  return lexer->source[MAX(lexer->current_position - offset, 0)];
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset) {
+  return lexer->source.data[MAX(lexer->current_position - offset, 0)];
 }
 
-char lexer_peek(const lexer_T* lexer, const int offset) {
-  return lexer->source[MIN(lexer->current_position + offset, lexer->source_length)];
+char lexer_peek(const lexer_T* lexer, uint32_t offset) {
+  return lexer->source.data[MIN(lexer->current_position + offset, lexer->source.length)];
 }
 
-bool lexer_peek_for(const lexer_T* lexer, const int offset, const char* pattern, const bool case_insensitive) {
-  for (int index = 0; pattern[index]; index++) {
-    const char character = lexer_peek(lexer, offset + index);
+bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, const bool case_insensitive) {
+  hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position + offset);
+  remaining_source.length = MIN(pattern.length, remaining_source.length);
 
-    if (case_insensitive) {
-      if (tolower(character) != tolower(pattern[index])) { return false; }
-    } else {
-      if (character != pattern[index]) { return false; }
-    }
+  if (case_insensitive) {
+    return hb_string_equals_case_insensitive(remaining_source, pattern);
+  } else {
+    return hb_string_equals(remaining_source, pattern);
   }
-
-  return true;
 }
 
-bool lexer_peek_for_doctype(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!DOCTYPE", true);
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<!DOCTYPE"), true);
 }
 
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<?xml", true);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<?xml"), true);
 }
 
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<![CDATA[", false);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<![CDATA["), false);
 }
 
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "]]>", false);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("]]>"), false);
 }
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!--", false);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<!--"), false);
 }
 
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-->", false);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("-->"), false);
 }
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%>", false);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("%>"), false);
 }
 
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-%>", false);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("-%>"), false);
 }
 
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%%>", false);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("%%>"), false);
 }
 
-bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "=%>", false);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("=%>"), false);
 }
 
-bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset) {
   return (
     lexer_peek_erb_close_tag(lexer, offset) || lexer_peek_erb_dash_close_tag(lexer, offset)
     || lexer_peek_erb_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
@@ -103,10 +101,10 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   return result;
 }
 
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, const int offset) {
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset) {
   if (lexer_peek(lexer, offset) != '<' || lexer_peek(lexer, offset + 1) != '/') { return false; }
 
-  int pos = offset + 2;
+  uint32_t pos = offset + 2;
 
   while (lexer_peek(lexer, pos) == ' ' || lexer_peek(lexer, pos) == '\t' || lexer_peek(lexer, pos) == '\n'
          || lexer_peek(lexer, pos) == '\r') {

package/extension/libherb/lexer_peek_helpers.h

@@ -20,25 +20,25 @@ typedef struct {
   lexer_state_T state;
 } lexer_state_snapshot_T;
 
-char lexer_peek(const lexer_T* lexer, int offset);
-bool lexer_peek_for_doctype(const lexer_T* lexer, int offset);
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, int offset);
+char lexer_peek(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset);
 
-char lexer_backtrack(const lexer_T* lexer, int offset);
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset);
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type);
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, int offset);
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset);
 
 lexer_state_snapshot_T lexer_save_state(lexer_T* lexer);
 void lexer_restore_state(lexer_T* lexer, lexer_state_snapshot_T snapshot);

package/extension/libherb/lexer_struct.h

@@ -1,6 +1,8 @@
 #ifndef HERB_LEXER_STRUCT_H
 #define HERB_LEXER_STRUCT_H
 
+#include "util/hb_string.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -12,8 +14,7 @@ typedef enum {
 } lexer_state_T;
 
 typedef struct LEXER_STRUCT {
-  const char* source;
-  uint32_t source_length;
+  hb_string_T source;
 
   uint32_t current_line;
   uint32_t current_column;