@herb-tools/node 0.7.5 → 0.8.0

package/extension/libherb/include/errors.h

@@ -1,15 +1,15 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.5/templates/src/include/errors.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/src/include/errors.h.erb
 
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
 
-#include "array.h"
-#include "buffer.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   UNEXPECTED_ERROR,
@@ -21,6 +21,8 @@ typedef enum {
   VOID_ELEMENT_CLOSING_TAG_ERROR,
   UNCLOSED_ELEMENT_ERROR,
   RUBY_PARSE_ERROR,
+  ERB_CONTROL_FLOW_SCOPE_ERROR,
+  MISSINGERB_END_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -84,24 +86,38 @@ typedef struct {
   const char* level;
 } RUBY_PARSE_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  const char* keyword;
+} ERB_CONTROL_FLOW_SCOPE_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  const char* keyword;
+} MISSINGERB_END_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
-void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, array_T* errors);
+void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
-void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, array_T* errors);
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_array_T* errors);
 MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end);
-void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, array_T* errors);
+void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_array_T* errors);
 MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end);
-void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, array_T* errors);
+void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors);
 TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end);
-void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, array_T* errors);
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_array_T* errors);
 QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end);
-void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, array_T* errors);
+void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, hb_array_T* errors);
 VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end);
-void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, array_T* errors);
+void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end);
-void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, array_T* errors);
+void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors);
 RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end);
-void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, array_T* errors);
+void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, hb_array_T* errors);
+ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* keyword, position_T start, position_T end);
+void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
+void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
@@ -115,11 +131,11 @@ const char* error_human_type(ERROR_T* error);
 
 void error_free(ERROR_T* error);
 
-void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, hb_buffer_T* buffer);
 
 void error_pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  hb_buffer_T* buffer
 );
 
 #endif

package/extension/libherb/include/extract.h

@@ -1,18 +1,18 @@
 #ifndef HERB_EXTRACT_H
 #define HERB_EXTRACT_H
 
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   HERB_EXTRACT_LANGUAGE_RUBY,
   HERB_EXTRACT_LANGUAGE_HTML,
 } herb_extract_language_T;
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
-void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output);
 
 char* herb_extract_ruby_with_semicolons(const char* source);
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output);
 
 char* herb_extract(const char* source, herb_extract_language_T language);
 char* herb_extract_from_file(const char* path, herb_extract_language_T language);

package/extension/libherb/include/herb.h

@@ -1,11 +1,11 @@
 #ifndef HERB_H
 #define HERB_H
 
-#include "array.h"
 #include "ast_node.h"
-#include "buffer.h"
 #include "extract.h"
 #include "parser.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 #include <stdint.h>
 
@@ -13,18 +13,17 @@
 extern "C" {
 #endif
 
-void herb_lex_to_buffer(const char* source, buffer_T* output);
-void herb_lex_json_to_buffer(const char* source, buffer_T* output);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
 
-array_T* herb_lex(const char* source);
-array_T* herb_lex_file(const char* path);
+hb_array_T* herb_lex(const char* source);
+hb_array_T* herb_lex_file(const char* path);
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
 
 const char* herb_version(void);
 const char* herb_prism_version(void);
 
-void herb_free_tokens(array_T** tokens);
+void herb_free_tokens(hb_array_T** tokens);
 
 #ifdef __cplusplus
 }

package/extension/libherb/include/html_util.h

@@ -1,13 +1,12 @@
 #ifndef HERB_HTML_UTIL_H
 #define HERB_HTML_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 
-bool is_void_element(const char* tag_name);
-bool is_html4_void_element(const char* tag_name);
+bool is_void_element(hb_string_T tag_name);
 
-char* html_opening_tag_string(const char* tag_name);
-char* html_closing_tag_string(const char* tag_name);
-char* html_self_closing_tag_string(const char* tag_name);
+hb_string_T html_closing_tag_string(hb_string_T tag_name);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name);
 
 #endif

package/extension/libherb/include/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/include/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/include/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;

package/extension/libherb/include/macros.h

@@ -5,6 +5,10 @@
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
+#define KB(kb) (1024 * (kb))
+
+#define MB(mb) (1024 * KB(mb))
+
 #define unlikely(x) __builtin_expect(!!(x), 0)
 
 #endif

package/extension/libherb/include/parser.h

@@ -1,9 +1,9 @@
 #ifndef HERB_PARSER_H
 #define HERB_PARSER_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_array.h"
 
 typedef enum {
   FOREIGN_CONTENT_UNKNOWN = 0,
@@ -19,21 +19,27 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
 } parser_options_T;
 
+extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+
 typedef struct PARSER_STRUCT {
   lexer_T* lexer;
   token_T* current_token;
-  array_T* open_tags_stack;
+  hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
-  parser_options_T* options;
+  parser_options_T options;
 } parser_T;
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options);
+size_t parser_sizeof(void);
+
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options);
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
-size_t parser_sizeof(void);
+void herb_parser_match_html_tags_post_analyze(AST_DOCUMENT_NODE_T* document);
+void herb_parser_deinit(parser_T* parser);
 
-void parser_free(parser_T* parser);
+void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors);
+bool match_tags_visitor(const AST_NODE_T* node, void* data);
 
 #endif

package/extension/libherb/include/parser_helpers.h

@@ -1,47 +1,57 @@
 #ifndef HERB_PARSER_HELPERS_H
 #define HERB_PARSER_HELPERS_H
 
-#include "array.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "errors.h"
 #include "parser.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name);
-bool parser_is_foreign_content_tag(const char* tag_name);
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
+bool parser_is_foreign_content_tag(hb_string_T tag_name);
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
 void parser_exit_foreign_content(parser_T* parser);
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type);
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
-token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
+);
+void parser_handle_mismatched_tags(
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  hb_array_T* errors
 );
-void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 
 #endif

package/extension/libherb/include/pretty_print.h

@@ -3,91 +3,101 @@
 
 #include "analyzed_ruby.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "location.h"
+#include "util/hb_buffer.h"
 
 #include <stdbool.h>
 
-void pretty_print_indent(buffer_T* buffer, size_t indent);
-void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
-void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
+void pretty_print_label(
+  hb_string_T name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_position_property(
   position_T* position,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_location(location_T location, buffer_T* buffer);
+void pretty_print_location(location_T location, hb_buffer_T* buffer);
 
 void pretty_print_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
   size_t value,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_string_property(
-  const char* string,
-  const char* name,
+  hb_string_T string,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
-  const char* name,
+  hb_string_T name,
   bool value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_token_property(
   token_T* token,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_array(
-  const char* name,
-  array_T* array,
+  hb_string_T name,
+  hb_array_T* array,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
+void pretty_print_errors(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 #endif

package/extension/libherb/include/token.h

@@ -4,19 +4,16 @@
 #include "lexer_struct.h"
 #include "position.h"
 #include "token_struct.h"
+#include "util/hb_string.h"
 
-token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
-char* token_to_string(const token_T* token);
-char* token_to_json(const token_T* token);
+token_T* token_init(hb_string_T value, token_type_T type, lexer_T* lexer);
+hb_string_T token_to_string(const token_T* token);
 const char* token_type_to_string(token_type_T type);
 
-char* token_value(const token_T* token);
-int token_type(const token_T* token);
-
-size_t token_sizeof(void);
-
 token_T* token_copy(token_T* token);
 
 void token_free(token_T* token);
 
+bool token_value_empty(const token_T* token);
+
 #endif

package/extension/libherb/include/utf8.h

@@ -2,10 +2,11 @@
 #define HERB_UTF8_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
-int utf8_char_byte_length(unsigned char first_byte);
-int utf8_sequence_length(const char* str, size_t position, size_t max_length);
+uint32_t utf8_char_byte_length(unsigned char first_byte);
+uint32_t utf8_sequence_length(const char* str, size_t position, size_t max_length);
 bool utf8_is_valid_continuation_byte(unsigned char byte);
 
 #endif

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

@@ -0,0 +1,31 @@
+#ifndef HERB_ARENA_H
+#define HERB_ARENA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct HB_ARENA_PAGE_STRUCT hb_arena_page_T;
+
+struct HB_ARENA_PAGE_STRUCT {
+  hb_arena_page_T* next;
+  size_t capacity;
+  size_t position;
+  char memory[];
+};
+
+typedef struct HB_ARENA_STRUCT {
+  hb_arena_page_T* head;
+  hb_arena_page_T* tail;
+  size_t default_page_size;
+  size_t allocation_count;
+} hb_arena_T;
+
+bool hb_arena_init(hb_arena_T* allocator, size_t initial_size);
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
+size_t hb_arena_position(hb_arena_T* allocator);
+size_t hb_arena_capacity(hb_arena_T* allocator);
+void hb_arena_reset(hb_arena_T* allocator);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_free(hb_arena_T* allocator);
+
+#endif

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

@@ -0,0 +1,8 @@
+#ifndef HERB_ARENA_DEBUG_H
+#define HERB_ARENA_DEBUG_H
+
+#include "hb_arena.h"
+
+void hb_arena_print_stats(const hb_arena_T* allocator);
+
+#endif

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

@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct HB_ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} hb_array_T;
+
+hb_array_T* hb_array_init(size_t capacity);
+
+void* hb_array_get(const hb_array_T* array, size_t index);
+void* hb_array_first(hb_array_T* array);
+void* hb_array_last(hb_array_T* array);
+
+void hb_array_append(hb_array_T* array, void* item);
+void hb_array_set(const hb_array_T* array, size_t index, void* item);
+void hb_array_free(hb_array_T** array);
+void hb_array_remove(hb_array_T* array, size_t index);
+
+size_t hb_array_index_of(hb_array_T* array, void* item);
+void hb_array_remove_item(hb_array_T* array, void* item);
+
+void hb_array_push(hb_array_T* array, void* item);
+void* hb_array_pop(hb_array_T* array);
+
+size_t hb_array_capacity(const hb_array_T* array);
+size_t hb_array_size(const hb_array_T* array);
+size_t hb_array_sizeof(void);
+
+#endif

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

@@ -0,0 +1,34 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include "hb_string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HB_BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} hb_buffer_T;
+
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+
+void hb_buffer_append(hb_buffer_T* buffer, const char* text);
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string);
+void hb_buffer_append_char(hb_buffer_T* buffer, char character);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
+
+char* hb_buffer_value(const hb_buffer_T* buffer);
+
+size_t hb_buffer_length(const hb_buffer_T* buffer);
+size_t hb_buffer_capacity(const hb_buffer_T* buffer);
+size_t hb_buffer_sizeof(void);
+
+void hb_buffer_clear(hb_buffer_T* buffer);
+void hb_buffer_free(hb_buffer_T** buffer);
+
+#endif