markly 0.16.0 → 0.18.0

data/ext/markly/markly.c

@@ -8,10 +8,9 @@
 #include "cmark-gfm-core-extensions.h"
 #include "front_matter.h"
 
-static VALUE rb_Markly;
-static VALUE rb_Markly_Error;
-static VALUE rb_Markly_Node;
-static VALUE rb_Markly_Parser;
+static VALUE Markly_Error;
+static VALUE Markly_Node;
+static VALUE Markly_Node_Fence;
 
 static VALUE sym_document;
 static VALUE sym_custom_block;
@@ -44,8 +43,8 @@ static VALUE sym_left;
 static VALUE sym_right;
 static VALUE sym_center;
 
-static void rb_Markly_Node_free(void *data) {
-	// If a parent of this node is already freed, `rb_Markly_Node_freed` will ensure all the nodes are nullified.
+static void Markly_Node_Type_free(void *data) {
+	// If a parent of this node is already freed, `Markly_Node_freed` will ensure all the nodes are nullified.
 	if (data) {
 		cmark_node *node = (cmark_node*)data;
 		
@@ -57,7 +56,7 @@ static void rb_Markly_Node_free(void *data) {
 	}
 }
 
-static void rb_Markly_Node_mark(void *data) {
+static void Markly_Node_Type_mark(void *data) {
 	cmark_node *node = data;
 	
 	// Mark the parent to make sure that the tree won't be freed as long as a child node is referenced.
@@ -77,23 +76,23 @@ static void rb_Markly_Node_mark(void *data) {
 	}
 }
 
-static const rb_data_type_t rb_Markly_Node_Type = {
+static const rb_data_type_t Markly_Node_Type = {
 	.wrap_struct_name = "Markly::Node",
 	.function = {
-		.dmark = rb_Markly_Node_mark,
-		.dfree = rb_Markly_Node_free,
+		.dmark = Markly_Node_Type_mark,
+		.dfree = Markly_Node_Type_free,
 	},
 	.data = NULL,
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static void rb_Markly_Node_freed(cmark_mem *mem, void *user_data) {
+static void Markly_Node_freed(cmark_mem *mem, void *user_data) {
 	VALUE self = (VALUE)user_data;
 	
 	RTYPEDDATA_DATA(self) = NULL;
 }
 
-static VALUE rb_Markly_Node_wrap(cmark_node *node) {
+static VALUE Markly_Node_wrap(cmark_node *node) {
 	if (node == NULL)
 		return Qnil;
 	
@@ -103,18 +102,18 @@ static VALUE rb_Markly_Node_wrap(cmark_node *node) {
 		return (VALUE)user_data;
 	}
 	
-	VALUE self = TypedData_Wrap_Struct(rb_Markly_Node, &rb_Markly_Node_Type, node);
+	VALUE self = TypedData_Wrap_Struct(Markly_Node, &Markly_Node_Type, node);
 	cmark_node_set_user_data(node, (void *)self);
-	cmark_node_set_user_data_free_func(node, rb_Markly_Node_freed);
+	cmark_node_set_user_data_free_func(node, Markly_Node_freed);
 	
 	return self;
 }
 
-static void rb_Markly_Parser_free(void *data) {
+static void Markly_Parser_Type_free(void *data) {
 	cmark_parser_free(data);
 }
 
-static void rb_Markly_Parser_mark(void *data) {
+static void Markly_Parser_Type_mark(void *data) {
 	cmark_parser *parser = data;
 	
 	// Mark the parent to make sure that the tree won't be freed as long as a child node is referenced.
@@ -126,21 +125,21 @@ static void rb_Markly_Parser_mark(void *data) {
 	}
 }
 
-static const rb_data_type_t rb_Markly_Parser_Type = {
+static const rb_data_type_t Markly_Parser_Type = {
 	.wrap_struct_name = "Markly::Parser",
 	.function = {
-		.dmark = rb_Markly_Parser_mark,
-		.dfree = rb_Markly_Parser_free,
+		.dmark = Markly_Parser_Type_mark,
+		.dfree = Markly_Parser_Type_free,
 	},
 	.data = NULL,
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static VALUE rb_Markly_Parser_alloc(VALUE self) {
-	return TypedData_Wrap_Struct(self, &rb_Markly_Parser_Type, NULL);
+static VALUE Markly_Parser_allocate(VALUE self) {
+	return TypedData_Wrap_Struct(self, &Markly_Parser_Type, NULL);
 }
 
-static VALUE rb_Markly_Parser_initialize(VALUE self, VALUE flags) {
+static VALUE Markly_Parser_initialize(VALUE self, VALUE flags) {
 	Check_Type(flags, T_FIXNUM);
 	
 	cmark_mem *mem = cmark_get_default_mem_allocator();
@@ -151,14 +150,14 @@ static VALUE rb_Markly_Parser_initialize(VALUE self, VALUE flags) {
 	return self;
 }
 
-static VALUE rb_Markly_Parser_enable(VALUE self, VALUE extension) {
+static VALUE Markly_Parser_enable(VALUE self, VALUE extension) {
 	cmark_parser *parser = NULL;
 	
 	Check_Type(extension, T_SYMBOL);
 	
 	VALUE extension_name = rb_sym2str(extension);
 	
-	TypedData_Get_Struct(self, cmark_parser, &rb_Markly_Parser_Type, parser);
+	TypedData_Get_Struct(self, cmark_parser, &Markly_Parser_Type, parser);
 	
 	cmark_syntax_extension *syntax_extension =
 		cmark_find_syntax_extension(StringValueCStr(extension_name));
@@ -172,18 +171,18 @@ static VALUE rb_Markly_Parser_enable(VALUE self, VALUE extension) {
 	return Qnil;
 }
 
-static VALUE rb_Markly_Parser_parse(VALUE self, VALUE text) {
+static VALUE Markly_Parser_parse(VALUE self, VALUE text) {
 	cmark_parser *parser = NULL;
 	
 	StringValue(text);
 	
-	TypedData_Get_Struct(self, cmark_parser, &rb_Markly_Parser_Type, parser);
+	TypedData_Get_Struct(self, cmark_parser, &Markly_Parser_Type, parser);
 	
 	cmark_parser_feed(parser, RSTRING_PTR(text), RSTRING_LEN(text));
 	
 	cmark_node *root = cmark_parser_finish(parser);
 	
-	return rb_Markly_Node_wrap(root);
+	return Markly_Node_wrap(root);
 }
 
 /*
@@ -211,7 +210,7 @@ static VALUE rb_Markly_Parser_parse(VALUE self, VALUE text) {
  * - `:link`
  * - `:image`
  */
-static VALUE rb_node_new(VALUE self, VALUE type) {
+static VALUE Markly_Node_new(VALUE self, VALUE type) {
 	cmark_node_type node_type = 0;
 	cmark_node *node;
 
@@ -262,26 +261,41 @@ static VALUE rb_node_new(VALUE self, VALUE type) {
 	else if (type == sym_footnote_definition)
 		node_type = CMARK_NODE_FOOTNOTE_DEFINITION;
 	else
-		rb_raise(rb_Markly_Error, "invalid node of type %d", node_type);
+		rb_raise(Markly_Error, "invalid node of type %d", node_type);
 
 	node = cmark_node_new(node_type);
 	if (node == NULL) {
-		rb_raise(rb_Markly_Error, "could not create node of type %d", node_type);
+		rb_raise(Markly_Error, "could not create node of type %d", node_type);
 	}
 
-	return rb_Markly_Node_wrap(node);
+	return Markly_Node_wrap(node);
 }
 
-static VALUE rb_node_replace(VALUE self, VALUE other) {
+/*
+ * Duplicate the current node and all its children.
+ */
+static VALUE Markly_Node_duplicate(VALUE self) {
+	cmark_node *node;
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
+
+	cmark_node *copy = cmark_node_clone(node);
+	if (copy == NULL) {
+		rb_raise(Markly_Error, "could not duplicate node");
+	}
+
+	return Markly_Node_wrap(copy);
+}
+
+static VALUE Markly_Node_replace(VALUE self, VALUE other) {
 	cmark_node *current_node = NULL, *replacement_node = NULL;
 	
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, current_node);
-	TypedData_Get_Struct(other, cmark_node, &rb_Markly_Node_Type, replacement_node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, current_node);
+	TypedData_Get_Struct(other, cmark_node, &Markly_Node_Type, replacement_node);
 	
 	int result = cmark_node_replace(current_node, replacement_node);
 	
 	if (result == 0) {
-		rb_raise(rb_Markly_Error, "could not replace node");
+		rb_raise(Markly_Error, "could not replace node");
 	}
 	
 	return other;
@@ -299,10 +313,10 @@ static VALUE encode_utf8_string(const char *c_string) {
  *
  * Returns a {String} or {nil} if there is no string content.
  */
-static VALUE rb_node_get_string_content(VALUE self) {
+static VALUE Markly_Node_get_string_content(VALUE self) {
 	const char *text;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	text = cmark_node_get_literal(node);
 
@@ -320,16 +334,16 @@ static VALUE rb_node_get_string_content(VALUE self) {
  *
  * Raises Error if the string content can't be set.
  */
-static VALUE rb_node_set_string_content(VALUE self, VALUE s) {
+static VALUE Markly_Node_set_string_content(VALUE self, VALUE s) {
 	char *text;
 	cmark_node *node;
 	Check_Type(s, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	text = StringValueCStr(s);
 
 	if (!cmark_node_set_literal(node, text)) {
-		rb_raise(rb_Markly_Error, "could not set string content");
+		rb_raise(Markly_Error, "could not set string content");
 	}
 
 	return Qnil;
@@ -340,13 +354,13 @@ static VALUE rb_node_set_string_content(VALUE self, VALUE s) {
  *
  * Returns a {Symbol} representing the node's type.
  */
-static VALUE rb_node_get_type(VALUE self) {
+static VALUE Markly_Node_get_type(VALUE self) {
 	int node_type = 0;
 	cmark_node *node = NULL;
 	VALUE symbol = Qnil;
 	const char *s = NULL;
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	node_type = cmark_node_get_type(node);
 	symbol = Qnil;
@@ -426,7 +440,7 @@ static VALUE rb_node_get_type(VALUE self) {
 			s = node->extension->get_type_string_func(node->extension, node);
 			return ID2SYM(rb_intern(s));
 		}
-		rb_raise(rb_Markly_Error, "invalid node type %d", node_type);
+		rb_raise(Markly_Error, "invalid node type %d", node_type);
 	}
 
 	return symbol;
@@ -437,12 +451,12 @@ static VALUE rb_node_get_type(VALUE self) {
  *
  * Returns a {Hash} containing {Symbol} keys of the positions.
  */
-static VALUE rb_node_get_source_position(VALUE self) {
+static VALUE Markly_Node_get_source_position(VALUE self) {
 	int start_line, start_column, end_line, end_column;
 	VALUE result;
 
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	start_line = cmark_node_get_start_line(node);
 	start_column = cmark_node_get_start_column(node);
@@ -463,9 +477,9 @@ static VALUE rb_node_get_source_position(VALUE self) {
  *
  * Returns a {String}.
  */
-static VALUE rb_node_get_type_string(VALUE self) {
+static VALUE Markly_Node_get_type_string(VALUE self) {
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	return rb_str_new2(cmark_node_get_type_string(node));
 }
@@ -474,9 +488,9 @@ static VALUE rb_node_get_type_string(VALUE self) {
  * Internal: Unlinks the node from the tree (fixing pointers in
  * parents and siblings appropriately).
  */
-static VALUE rb_node_unlink(VALUE self) {
+static VALUE Markly_Node_unlink(VALUE self) {
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	cmark_node_unlink(node);
 
@@ -487,26 +501,26 @@ static VALUE rb_node_unlink(VALUE self) {
  *
  * Returns a {Node} if a child exists, `nil` otherise.
  */
-static VALUE rb_node_first_child(VALUE self) {
+static VALUE Markly_Node_first_child(VALUE self) {
 	cmark_node *node, *child;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	child = cmark_node_first_child(node);
 
-	return rb_Markly_Node_wrap(child);
+	return Markly_Node_wrap(child);
 }
 
 /* Public: Fetches the next sibling of the node.
  *
  * Returns a {Node} if a sibling exists, `nil` otherwise.
  */
-static VALUE rb_node_next(VALUE self) {
+static VALUE Markly_Node_next(VALUE self) {
 	cmark_node *node, *next;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	next = cmark_node_next(node);
 
-	return rb_Markly_Node_wrap(next);
+	return Markly_Node_wrap(next);
 }
 
 /*
@@ -517,13 +531,13 @@ static VALUE rb_node_next(VALUE self) {
  * Returns `true` if successful.
  * Raises Error if the node can't be inserted.
  */
-static VALUE rb_node_insert_before(VALUE self, VALUE sibling) {
+static VALUE Markly_Node_insert_before(VALUE self, VALUE sibling) {
 	cmark_node *node1, *node2;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node1);
-	TypedData_Get_Struct(sibling, cmark_node, &rb_Markly_Node_Type, node2);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
+	TypedData_Get_Struct(sibling, cmark_node, &Markly_Node_Type, node2);
 
 	if (!cmark_node_insert_before(node1, node2)) {
-		rb_raise(rb_Markly_Error, "could not insert before");
+		rb_raise(Markly_Error, "could not insert before");
 	}
 
 	return Qtrue;
@@ -533,7 +547,7 @@ static VALUE rb_node_insert_before(VALUE self, VALUE sibling) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
+static VALUE Markly_Node_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
 	VALUE rb_ext_name;
 	int i;
 	cmark_node *node;
@@ -545,7 +559,7 @@ static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
 	int options = FIX2INT(rb_options);
 	long extensions_len = RARRAY_LEN(rb_extensions);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	for (i = 0; i < extensions_len; ++i) {
 		rb_ext_name = RARRAY_PTR(rb_extensions)[i];
@@ -579,7 +593,7 @@ static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_commonmark(int argc, VALUE *argv, VALUE self) {
+static VALUE Markly_Node_render_commonmark(int argc, VALUE *argv, VALUE self) {
 	VALUE rb_options, rb_width;
 	rb_scan_args(argc, argv, "11", &rb_options, &rb_width);
 
@@ -594,7 +608,7 @@ static VALUE rb_render_commonmark(int argc, VALUE *argv, VALUE self) {
 	Check_Type(rb_options, T_FIXNUM);
 
 	options = FIX2INT(rb_options);
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	char *cmark = cmark_render_commonmark(node, options, width);
 	VALUE ruby_cmark = rb_str_new2(cmark);
@@ -607,7 +621,7 @@ static VALUE rb_render_commonmark(int argc, VALUE *argv, VALUE self) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_plaintext(int argc, VALUE *argv, VALUE self) {
+static VALUE Markly_Node_render_plaintext(int argc, VALUE *argv, VALUE self) {
 	VALUE rb_options, rb_width;
 	rb_scan_args(argc, argv, "11", &rb_options, &rb_width);
 
@@ -622,7 +636,7 @@ static VALUE rb_render_plaintext(int argc, VALUE *argv, VALUE self) {
 	Check_Type(rb_options, T_FIXNUM);
 
 	options = FIX2INT(rb_options);
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	char *text = cmark_render_plaintext(node, options, width);
 	VALUE ruby_text = rb_str_new2(text);
@@ -639,13 +653,13 @@ static VALUE rb_render_plaintext(int argc, VALUE *argv, VALUE self) {
  * Returns `true` if successful.
  * Raises Error if the node can't be inserted.
  */
-static VALUE rb_node_insert_after(VALUE self, VALUE sibling) {
+static VALUE Markly_Node_insert_after(VALUE self, VALUE sibling) {
 	cmark_node *node1, *node2;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node1);
-	TypedData_Get_Struct(sibling, cmark_node, &rb_Markly_Node_Type, node2);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
+	TypedData_Get_Struct(sibling, cmark_node, &Markly_Node_Type, node2);
 
 	if (!cmark_node_insert_after(node1, node2)) {
-		rb_raise(rb_Markly_Error, "could not insert after");
+		rb_raise(Markly_Error, "could not insert after");
 	}
 
 	return Qtrue;
@@ -659,13 +673,13 @@ static VALUE rb_node_insert_after(VALUE self, VALUE sibling) {
  * Returns `true` if successful.
  * Raises Error if the node can't be inserted.
  */
-static VALUE rb_node_prepend_child(VALUE self, VALUE child) {
+static VALUE Markly_Node_prepend_child(VALUE self, VALUE child) {
 	cmark_node *node1, *node2;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node1);
-	TypedData_Get_Struct(child, cmark_node, &rb_Markly_Node_Type, node2);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
+	TypedData_Get_Struct(child, cmark_node, &Markly_Node_Type, node2);
 
 	if (!cmark_node_prepend_child(node1, node2)) {
-		rb_raise(rb_Markly_Error, "could not prepend child");
+		rb_raise(Markly_Error, "could not prepend child");
 	}
 
 	return Qtrue;
@@ -679,13 +693,13 @@ static VALUE rb_node_prepend_child(VALUE self, VALUE child) {
  * Returns `true` if successful.
  * Raises Error if the node can't be inserted.
  */
-static VALUE rb_node_append_child(VALUE self, VALUE child) {
+static VALUE Markly_Node_append_child(VALUE self, VALUE child) {
 	cmark_node *node1, *node2;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node1);
-	TypedData_Get_Struct(child, cmark_node, &rb_Markly_Node_Type, node2);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
+	TypedData_Get_Struct(child, cmark_node, &Markly_Node_Type, node2);
 
 	if (!cmark_node_append_child(node1, node2)) {
-		rb_raise(rb_Markly_Error, "could not append child");
+		rb_raise(Markly_Error, "could not append child");
 	}
 
 	return Qtrue;
@@ -695,39 +709,39 @@ static VALUE rb_node_append_child(VALUE self, VALUE child) {
  *
  * Returns a {Node} if a child exists, `nil` otherise.
  */
-static VALUE rb_node_last_child(VALUE self) {
+static VALUE Markly_Node_last_child(VALUE self) {
 	cmark_node *node, *child;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	child = cmark_node_last_child(node);
 
-	return rb_Markly_Node_wrap(child);
+	return Markly_Node_wrap(child);
 }
 
 /* Public: Fetches the parent of the current node.
  *
  * Returns a {Node} if a parent exists, `nil` otherise.
  */
-static VALUE rb_node_parent(VALUE self) {
+static VALUE Markly_Node_parent(VALUE self) {
 	cmark_node *node, *parent;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	parent = cmark_node_parent(node);
 
-	return rb_Markly_Node_wrap(parent);
+	return Markly_Node_wrap(parent);
 }
 
 /* Public: Fetches the previous sibling of the current node.
  *
  * Returns a {Node} if a parent exists, `nil` otherise.
  */
-static VALUE rb_node_previous(VALUE self) {
+static VALUE Markly_Node_previous(VALUE self) {
 	cmark_node *node, *previous;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	previous = cmark_node_previous(node);
 
-	return rb_Markly_Node_wrap(previous);
+	return Markly_Node_wrap(previous);
 }
 
 /*
@@ -736,14 +750,14 @@ static VALUE rb_node_previous(VALUE self) {
  * Returns a {String}.
  * Raises a Error if the URL can't be retrieved.
  */
-static VALUE rb_node_get_url(VALUE self) {
+static VALUE Markly_Node_get_url(VALUE self) {
 	const char *text;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	text = cmark_node_get_url(node);
 	if (text == NULL) {
-		rb_raise(rb_Markly_Error, "could not get url");
+		rb_raise(Markly_Error, "could not get url");
 	}
 
 	return rb_str_new2(text);
@@ -756,16 +770,16 @@ static VALUE rb_node_get_url(VALUE self) {
  *
  * Raises a Error if the URL can't be set.
  */
-static VALUE rb_node_set_url(VALUE self, VALUE url) {
+static VALUE Markly_Node_set_url(VALUE self, VALUE url) {
 	cmark_node *node;
 	char *text;
 	Check_Type(url, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	text = StringValueCStr(url);
 
 	if (!cmark_node_set_url(node, text)) {
-		rb_raise(rb_Markly_Error, "could not set url");
+		rb_raise(Markly_Error, "could not set url");
 	}
 
 	return Qnil;
@@ -777,14 +791,14 @@ static VALUE rb_node_set_url(VALUE self, VALUE url) {
  * Returns a {String}.
  * Raises a Error if the title can't be retrieved.
  */
-static VALUE rb_node_get_title(VALUE self) {
+static VALUE Markly_Node_get_title(VALUE self) {
 	const char *text;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	text = cmark_node_get_title(node);
 	if (text == NULL) {
-		rb_raise(rb_Markly_Error, "could not get title");
+		rb_raise(Markly_Error, "could not get title");
 	}
 
 	return rb_str_new2(text);
@@ -797,16 +811,16 @@ static VALUE rb_node_get_title(VALUE self) {
  *
  * Raises a Error if the title can't be set.
  */
-static VALUE rb_node_set_title(VALUE self, VALUE title) {
+static VALUE Markly_Node_set_title(VALUE self, VALUE title) {
 	char *text;
 	cmark_node *node;
 	Check_Type(title, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	text = StringValueCStr(title);
 
 	if (!cmark_node_set_title(node, text)) {
-		rb_raise(rb_Markly_Error, "could not set title");
+		rb_raise(Markly_Error, "could not set title");
 	}
 
 	return Qnil;
@@ -818,15 +832,15 @@ static VALUE rb_node_set_title(VALUE self, VALUE title) {
  * Returns a {Number} representing the header level.
  * Raises a Error if the header level can't be retrieved.
  */
-static VALUE rb_node_get_header_level(VALUE self) {
+static VALUE Markly_Node_get_header_level(VALUE self) {
 	int header_level;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	header_level = cmark_node_get_header_level(node);
 
 	if (header_level == 0) {
-		rb_raise(rb_Markly_Error, "could not get header_level");
+		rb_raise(Markly_Error, "could not get header_level");
 	}
 
 	return INT2NUM(header_level);
@@ -839,16 +853,16 @@ static VALUE rb_node_get_header_level(VALUE self) {
  *
  * Raises a Error if the header level can't be set.
  */
-static VALUE rb_node_set_header_level(VALUE self, VALUE level) {
+static VALUE Markly_Node_set_header_level(VALUE self, VALUE level) {
 	int l;
 	cmark_node *node;
 	Check_Type(level, T_FIXNUM);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	l = FIX2INT(level);
 
 	if (!cmark_node_set_header_level(node, l)) {
-		rb_raise(rb_Markly_Error, "could not set header_level");
+		rb_raise(Markly_Error, "could not set header_level");
 	}
 
 	return Qnil;
@@ -860,11 +874,11 @@ static VALUE rb_node_set_header_level(VALUE self, VALUE level) {
  * Returns a {Symbol}.
  * Raises a Error if the title can't be retrieved.
  */
-static VALUE rb_node_get_list_type(VALUE self) {
+static VALUE Markly_Node_get_list_type(VALUE self) {
 	int list_type;
 	cmark_node *node;
 	VALUE symbol;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	list_type = cmark_node_get_list_type(node);
 
@@ -873,7 +887,7 @@ static VALUE rb_node_get_list_type(VALUE self) {
 	} else if (list_type == CMARK_ORDERED_LIST) {
 		symbol = sym_ordered_list;
 	} else {
-		rb_raise(rb_Markly_Error, "could not get list_type");
+		rb_raise(Markly_Error, "could not get list_type");
 	}
 
 	return symbol;
@@ -886,23 +900,23 @@ static VALUE rb_node_get_list_type(VALUE self) {
  *
  * Raises a Error if the list type can't be set.
  */
-static VALUE rb_node_set_list_type(VALUE self, VALUE list_type) {
+static VALUE Markly_Node_set_list_type(VALUE self, VALUE list_type) {
 	int type = 0;
 	cmark_node *node;
 	Check_Type(list_type, T_SYMBOL);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	if (list_type == sym_bullet_list) {
 		type = CMARK_BULLET_LIST;
 	} else if (list_type == sym_ordered_list) {
 		type = CMARK_ORDERED_LIST;
 	} else {
-		rb_raise(rb_Markly_Error, "invalid list_type");
+		rb_raise(Markly_Error, "invalid list_type");
 	}
 
 	if (!cmark_node_set_list_type(node, type)) {
-		rb_raise(rb_Markly_Error, "could not set list_type");
+		rb_raise(Markly_Error, "could not set list_type");
 	}
 
 	return Qnil;
@@ -915,13 +929,13 @@ static VALUE rb_node_set_list_type(VALUE self, VALUE list_type) {
  * Returns a {Number} representing the starting number.
  * Raises a Error if the starting number can't be retrieved.
  */
-static VALUE rb_node_get_list_start(VALUE self) {
+static VALUE Markly_Node_get_list_start(VALUE self) {
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	if (cmark_node_get_type(node) != CMARK_NODE_LIST ||
 			cmark_node_get_list_type(node) != CMARK_ORDERED_LIST) {
-		rb_raise(rb_Markly_Error, "can't get list_start for non-ordered list %d",
+		rb_raise(Markly_Error, "can't get list_start for non-ordered list %d",
 						 cmark_node_get_list_type(node));
 	}
 
@@ -936,16 +950,16 @@ static VALUE rb_node_get_list_start(VALUE self) {
  *
  * Raises a Error if the starting number can't be set.
  */
-static VALUE rb_node_set_list_start(VALUE self, VALUE start) {
+static VALUE Markly_Node_set_list_start(VALUE self, VALUE start) {
 	int s;
 	cmark_node *node;
 	Check_Type(start, T_FIXNUM);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	s = FIX2INT(start);
 
 	if (!cmark_node_set_list_start(node, s)) {
-		rb_raise(rb_Markly_Error, "could not set list_start");
+		rb_raise(Markly_Error, "could not set list_start");
 	}
 
 	return Qnil;
@@ -957,13 +971,13 @@ static VALUE rb_node_set_list_start(VALUE self, VALUE start) {
  * Returns a `true` if the list is tight, `false` otherwise.
  * Raises a Error if the starting number can't be retrieved.
  */
-static VALUE rb_node_get_list_tight(VALUE self) {
+static VALUE Markly_Node_get_list_tight(VALUE self) {
 	int flag;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	if (cmark_node_get_type(node) != CMARK_NODE_LIST) {
-		rb_raise(rb_Markly_Error, "can't get list_tight for non-list");
+		rb_raise(Markly_Error, "can't get list_tight for non-list");
 	}
 
 	flag = cmark_node_get_list_tight(node);
@@ -978,14 +992,14 @@ static VALUE rb_node_get_list_tight(VALUE self) {
  *
  * Raises a Error if the tightness can't be set.
  */
-static VALUE rb_node_set_list_tight(VALUE self, VALUE tight) {
+static VALUE Markly_Node_set_list_tight(VALUE self, VALUE tight) {
 	int t;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	t = RTEST(tight);
 
 	if (!cmark_node_set_list_tight(node, t)) {
-		rb_raise(rb_Markly_Error, "could not set list_tight");
+		rb_raise(Markly_Error, "could not set list_tight");
 	}
 
 	return Qnil;
@@ -997,15 +1011,15 @@ static VALUE rb_node_set_list_tight(VALUE self, VALUE tight) {
  * Returns a {String} representing the fence info.
  * Raises a Error if the fence info can't be retrieved.
  */
-static VALUE rb_node_get_fence_info(VALUE self) {
+static VALUE Markly_Node_get_fence_info(VALUE self) {
 	const char *fence_info;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	fence_info = cmark_node_get_fence_info(node);
 
 	if (fence_info == NULL) {
-		rb_raise(rb_Markly_Error, "could not get fence_info");
+		rb_raise(Markly_Error, "could not get fence_info");
 	}
 
 	return rb_str_new2(fence_info);
@@ -1018,25 +1032,96 @@ static VALUE rb_node_get_fence_info(VALUE self) {
  *
  * Raises a Error if the fence info can't be set.
  */
-static VALUE rb_node_set_fence_info(VALUE self, VALUE info) {
+static VALUE Markly_Node_set_fence_info(VALUE self, VALUE info) {
 	char *text;
 	cmark_node *node;
 	Check_Type(info, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	text = StringValueCStr(info);
 
 	if (!cmark_node_set_fence_info(node, text)) {
-		rb_raise(rb_Markly_Error, "could not set fence_info");
+		rb_raise(Markly_Error, "could not set fence_info");
 	}
 
 	return Qnil;
 }
 
-static VALUE rb_node_get_tasklist_item_checked(VALUE self) {
+/*
+ * Public: Gets the code info of the current node (must be a `:code_block`,
+ * `:front_matter`, or inline `:code` node).
+ *
+ * Returns a {String} representing the code info.
+ * Raises a Error if the code info can't be retrieved.
+ */
+static VALUE Markly_Node_get_code_info(VALUE self) {
+	const char *code_info;
+	cmark_node *node;
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
+
+	code_info = cmark_node_get_code_info(node);
+
+	if (code_info == NULL) {
+		rb_raise(Markly_Error, "could not get code_info");
+	}
+
+	return rb_str_new2(code_info);
+}
+
+/*
+ * Public: Sets the code info of the current node (must be a `:code_block`,
+ * `:front_matter`, or inline `:code` node).
+ *
+ * info - A {String} representing the new code info, or `nil` to clear it.
+ *
+ * Raises a Error if the code info can't be set.
+ */
+static VALUE Markly_Node_set_code_info(VALUE self, VALUE info) {
+	const char *text = NULL;
+	cmark_node *node;
+
+	if (!NIL_P(info)) {
+		Check_Type(info, T_STRING);
+		text = StringValueCStr(info);
+	}
+
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
+
+	if (!cmark_node_set_code_info(node, text)) {
+		rb_raise(Markly_Error, "could not set code_info");
+	}
+
+	return Qnil;
+}
+
+/*
+ * Public: Gets fencing details for the current node.
+ *
+ * Returns a {Markly::Node::Fence} for fenced code blocks, `nil` otherwise.
+ */
+static VALUE Markly_Node_get_fence(VALUE self) {
+	int fence_length = 0;
+	int fence_offset = 0;
+	char fence_character = '\0';
+	cmark_node *node;
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
+	
+	if (!cmark_node_get_fenced(node, &fence_length, &fence_offset, &fence_character)) {
+		return Qnil;
+	}
+	
+	return rb_struct_new(
+		Markly_Node_Fence,
+		rb_str_new(&fence_character, 1),
+		INT2NUM(fence_length),
+		INT2NUM(fence_offset)
+	);
+}
+
+static VALUE Markly_Node_tasklist_item_checked_p(VALUE self) {
 	int tasklist_state;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	tasklist_state = cmark_gfm_extensions_get_tasklist_item_checked(node);
 
@@ -1055,14 +1140,14 @@ static VALUE rb_node_get_tasklist_item_checked(VALUE self) {
  * Returns a {Boolean} representing the new checkbox state.
  * Raises a Error if the checkbox state can't be set.
  */
-static VALUE rb_node_set_tasklist_item_checked(VALUE self, VALUE item_checked) {
+static VALUE Markly_Node_set_tasklist_item_checked(VALUE self, VALUE item_checked) {
 	int tasklist_state;
 	cmark_node *node;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 	tasklist_state = RTEST(item_checked);
 
 	if (!cmark_gfm_extensions_set_tasklist_item_checked(node, tasklist_state)) {
-		rb_raise(rb_Markly_Error, "could not set tasklist_item_checked");
+		rb_raise(Markly_Error, "could not set tasklist_item_checked");
 	};
 
 	if (tasklist_state) {
@@ -1072,28 +1157,28 @@ static VALUE rb_node_set_tasklist_item_checked(VALUE self, VALUE item_checked) {
 	}
 }
 
-static VALUE rb_node_get_parent_footnote_def(VALUE self) {
+static VALUE Markly_Node_get_parent_footnote_def(VALUE self) {
 	cmark_node *node;
 	cmark_node *parent;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	parent = cmark_node_parent_footnote_def(node);
 
-	return rb_Markly_Node_wrap(parent);
+	return Markly_Node_wrap(parent);
 }
 
-static VALUE rb_node_get_table_alignments(VALUE self) {
+static VALUE Markly_Node_get_table_alignments(VALUE self) {
 	uint16_t column_count, i;
 	uint8_t *alignments;
 	cmark_node *node;
 	VALUE ary;
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	column_count = cmark_gfm_extensions_get_table_columns(node);
 	alignments = cmark_gfm_extensions_get_table_alignments(node);
 
 	if (!column_count || !alignments) {
-		rb_raise(rb_Markly_Error, "could not get column_count or alignments");
+		rb_raise(Markly_Error, "could not get column_count or alignments");
 	}
 
 	ary = rb_ary_new();
@@ -1111,12 +1196,12 @@ static VALUE rb_node_get_table_alignments(VALUE self) {
 }
 
 /* Internal: Escapes href URLs safely. */
-static VALUE rb_html_escape_href(VALUE self, VALUE rb_text) {
+static VALUE Markly_Node_html_escape_href(VALUE self, VALUE rb_text) {
 	char *result;
 	cmark_node *node;
 	Check_Type(rb_text, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	cmark_mem *mem = cmark_node_mem(node);
 	cmark_strbuf buf = CMARK_BUF_INIT(mem);
@@ -1131,12 +1216,12 @@ static VALUE rb_html_escape_href(VALUE self, VALUE rb_text) {
 }
 
 /* Internal: Escapes HTML content safely. */
-static VALUE rb_html_escape_html(VALUE self, VALUE rb_text) {
+static VALUE Markly_Node_html_escape_html(VALUE self, VALUE rb_text) {
 	char *result;
 	cmark_node *node;
 	Check_Type(rb_text, T_STRING);
 
-	TypedData_Get_Struct(self, cmark_node, &rb_Markly_Node_Type, node);
+	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
 
 	cmark_mem *mem = cmark_node_mem(node);
 	cmark_strbuf buf = CMARK_BUF_INIT(mem);
@@ -1150,7 +1235,7 @@ static VALUE rb_html_escape_html(VALUE self, VALUE rb_text) {
 	return rb_text;
 }
 
-VALUE rb_Markly_extensions(VALUE self) {
+static VALUE Markly_extensions(VALUE self) {
 	cmark_llist *exts, *it;
 	cmark_syntax_extension *ext;
 	VALUE ary = rb_ary_new();
@@ -1167,7 +1252,7 @@ VALUE rb_Markly_extensions(VALUE self) {
 	return ary;
 }
 
-__attribute__((visibility("default"))) void Init_markly(void) {
+static void Init_Markly_Node(VALUE Markly) {
 	sym_document = ID2SYM(rb_intern("document"));
 	sym_custom_block = ID2SYM(rb_intern("custom_block"));
 	sym_custom_inline = ID2SYM(rb_intern("custom_inline"));
@@ -1199,63 +1284,75 @@ __attribute__((visibility("default"))) void Init_markly(void) {
 	sym_right = ID2SYM(rb_intern("right"));
 	sym_center = ID2SYM(rb_intern("center"));
 	
-	rb_Markly = rb_define_module("Markly");
-	rb_define_singleton_method(rb_Markly, "extensions", rb_Markly_extensions, 0);
-	
-	rb_Markly_Error = rb_define_class_under(rb_Markly, "Error", rb_eStandardError);
+	Markly_Node = rb_define_class_under(Markly, "Node", rb_cObject);
+	rb_undef_alloc_func(Markly_Node);
+	rb_define_singleton_method(Markly_Node, "new", Markly_Node_new, 1);
+	Markly_Node_Fence = rb_struct_define_under(Markly_Node, "Fence", "character", "length", "indent", NULL);
+	rb_define_method(Markly_Node, "_dup", Markly_Node_duplicate, 0);
+
+	rb_define_method(Markly_Node, "replace", Markly_Node_replace, 1);
+
+	rb_define_method(Markly_Node, "string_content", Markly_Node_get_string_content, 0);
+	rb_define_method(Markly_Node, "string_content=", Markly_Node_set_string_content, 1);
+	rb_define_method(Markly_Node, "type", Markly_Node_get_type, 0);
+	rb_define_method(Markly_Node, "type_string", Markly_Node_get_type_string, 0);
+	rb_define_method(Markly_Node, "source_position", Markly_Node_get_source_position, 0);
+	rb_define_method(Markly_Node, "delete", Markly_Node_unlink, 0);
+	rb_define_method(Markly_Node, "first_child", Markly_Node_first_child, 0);
+	rb_define_method(Markly_Node, "next", Markly_Node_next, 0);
+	rb_define_method(Markly_Node, "insert_before", Markly_Node_insert_before, 1);
+	rb_define_method(Markly_Node, "_render_html", Markly_Node_render_html, 2);
+	rb_define_method(Markly_Node, "_render_commonmark", Markly_Node_render_commonmark, -1);
+	rb_define_method(Markly_Node, "_render_plaintext", Markly_Node_render_plaintext, -1);
+	rb_define_method(Markly_Node, "insert_after", Markly_Node_insert_after, 1);
+	rb_define_method(Markly_Node, "prepend_child", Markly_Node_prepend_child, 1);
+	rb_define_method(Markly_Node, "append_child", Markly_Node_append_child, 1);
+	rb_define_method(Markly_Node, "last_child", Markly_Node_last_child, 0);
+	rb_define_method(Markly_Node, "parent", Markly_Node_parent, 0);
+	rb_define_method(Markly_Node, "previous", Markly_Node_previous, 0);
+	rb_define_method(Markly_Node, "url", Markly_Node_get_url, 0);
+	rb_define_method(Markly_Node, "url=", Markly_Node_set_url, 1);
+	rb_define_method(Markly_Node, "title", Markly_Node_get_title, 0);
+	rb_define_method(Markly_Node, "title=", Markly_Node_set_title, 1);
+	rb_define_method(Markly_Node, "header_level", Markly_Node_get_header_level, 0);
+	rb_define_method(Markly_Node, "header_level=", Markly_Node_set_header_level, 1);
+	rb_define_method(Markly_Node, "list_type", Markly_Node_get_list_type, 0);
+	rb_define_method(Markly_Node, "list_type=", Markly_Node_set_list_type, 1);
+	rb_define_method(Markly_Node, "list_start", Markly_Node_get_list_start, 0);
+	rb_define_method(Markly_Node, "list_start=", Markly_Node_set_list_start, 1);
+	rb_define_method(Markly_Node, "list_tight", Markly_Node_get_list_tight, 0);
+	rb_define_method(Markly_Node, "list_tight=", Markly_Node_set_list_tight, 1);
+	rb_define_method(Markly_Node, "fence_info", Markly_Node_get_fence_info, 0);
+	rb_define_method(Markly_Node, "fence_info=", Markly_Node_set_fence_info, 1);
+	rb_define_method(Markly_Node, "code_info", Markly_Node_get_code_info, 0);
+	rb_define_method(Markly_Node, "code_info=", Markly_Node_set_code_info, 1);
+	rb_define_method(Markly_Node, "fence", Markly_Node_get_fence, 0);
+	rb_define_method(Markly_Node, "table_alignments", Markly_Node_get_table_alignments, 0);
+	rb_define_method(Markly_Node, "tasklist_item_checked?", Markly_Node_tasklist_item_checked_p, 0);
+	rb_define_method(Markly_Node, "tasklist_item_checked=", Markly_Node_set_tasklist_item_checked, 1);
+
+	rb_define_method(Markly_Node, "parent_footnote_def", Markly_Node_get_parent_footnote_def, 0);
+
+	rb_define_method(Markly_Node, "html_escape_href", Markly_Node_html_escape_href, 1);
+	rb_define_method(Markly_Node, "html_escape_html", Markly_Node_html_escape_html, 1);
+}
+
+static void Init_Markly_Parser(VALUE Markly) {
+	VALUE Markly_Parser = rb_define_class_under(Markly, "Parser", rb_cObject);
+	rb_define_alloc_func(Markly_Parser, Markly_Parser_allocate);
+	rb_define_method(Markly_Parser, "initialize", Markly_Parser_initialize, 1);
+	rb_define_method(Markly_Parser, "enable", Markly_Parser_enable, 1);
+	rb_define_method(Markly_Parser, "parse", Markly_Parser_parse, 1);
+}
+
+__attribute__((visibility("default"))) void Init_markly(void) {
+	VALUE Markly = rb_define_module("Markly");
+	rb_define_singleton_method(Markly, "extensions", Markly_extensions, 0);
 	
-	rb_Markly_Parser = rb_define_class_under(rb_Markly, "Parser", rb_cObject);
-	rb_define_alloc_func(rb_Markly_Parser, rb_Markly_Parser_alloc);
-	rb_define_method(rb_Markly_Parser, "initialize", rb_Markly_Parser_initialize, 1);
-	rb_define_method(rb_Markly_Parser, "enable", rb_Markly_Parser_enable, 1);
-	rb_define_method(rb_Markly_Parser, "parse", rb_Markly_Parser_parse, 1);
+	Markly_Error = rb_define_class_under(Markly, "Error", rb_eStandardError);
 	
-	rb_Markly_Node = rb_define_class_under(rb_Markly, "Node", rb_cObject);
-	rb_undef_alloc_func(rb_Markly_Node);
-	rb_define_singleton_method(rb_Markly_Node, "new", rb_node_new, 1);
-
-	rb_define_method(rb_Markly_Node, "replace", rb_node_replace, 1);
-
-	rb_define_method(rb_Markly_Node, "string_content", rb_node_get_string_content, 0);
-	rb_define_method(rb_Markly_Node, "string_content=", rb_node_set_string_content, 1);
-	rb_define_method(rb_Markly_Node, "type", rb_node_get_type, 0);
-	rb_define_method(rb_Markly_Node, "type_string", rb_node_get_type_string, 0);
-	rb_define_method(rb_Markly_Node, "source_position", rb_node_get_source_position, 0);
-	rb_define_method(rb_Markly_Node, "delete", rb_node_unlink, 0);
-	rb_define_method(rb_Markly_Node, "first_child", rb_node_first_child, 0);
-	rb_define_method(rb_Markly_Node, "next", rb_node_next, 0);
-	rb_define_method(rb_Markly_Node, "insert_before", rb_node_insert_before, 1);
-	rb_define_method(rb_Markly_Node, "_render_html", rb_render_html, 2);
-	rb_define_method(rb_Markly_Node, "_render_commonmark", rb_render_commonmark, -1);
-	rb_define_method(rb_Markly_Node, "_render_plaintext", rb_render_plaintext, -1);
-	rb_define_method(rb_Markly_Node, "insert_after", rb_node_insert_after, 1);
-	rb_define_method(rb_Markly_Node, "prepend_child", rb_node_prepend_child, 1);
-	rb_define_method(rb_Markly_Node, "append_child", rb_node_append_child, 1);
-	rb_define_method(rb_Markly_Node, "last_child", rb_node_last_child, 0);
-	rb_define_method(rb_Markly_Node, "parent", rb_node_parent, 0);
-	rb_define_method(rb_Markly_Node, "previous", rb_node_previous, 0);
-	rb_define_method(rb_Markly_Node, "url", rb_node_get_url, 0);
-	rb_define_method(rb_Markly_Node, "url=", rb_node_set_url, 1);
-	rb_define_method(rb_Markly_Node, "title", rb_node_get_title, 0);
-	rb_define_method(rb_Markly_Node, "title=", rb_node_set_title, 1);
-	rb_define_method(rb_Markly_Node, "header_level", rb_node_get_header_level, 0);
-	rb_define_method(rb_Markly_Node, "header_level=", rb_node_set_header_level, 1);
-	rb_define_method(rb_Markly_Node, "list_type", rb_node_get_list_type, 0);
-	rb_define_method(rb_Markly_Node, "list_type=", rb_node_set_list_type, 1);
-	rb_define_method(rb_Markly_Node, "list_start", rb_node_get_list_start, 0);
-	rb_define_method(rb_Markly_Node, "list_start=", rb_node_set_list_start, 1);
-	rb_define_method(rb_Markly_Node, "list_tight", rb_node_get_list_tight, 0);
-	rb_define_method(rb_Markly_Node, "list_tight=", rb_node_set_list_tight, 1);
-	rb_define_method(rb_Markly_Node, "fence_info", rb_node_get_fence_info, 0);
-	rb_define_method(rb_Markly_Node, "fence_info=", rb_node_set_fence_info, 1);
-	rb_define_method(rb_Markly_Node, "table_alignments", rb_node_get_table_alignments, 0);
-	rb_define_method(rb_Markly_Node, "tasklist_item_checked?", rb_node_get_tasklist_item_checked, 0);
-	rb_define_method(rb_Markly_Node, "tasklist_item_checked=", rb_node_set_tasklist_item_checked, 1);
-
-	rb_define_method(rb_Markly_Node, "parent_footnote_def", rb_node_get_parent_footnote_def, 0);
-
-	rb_define_method(rb_Markly_Node, "html_escape_href", rb_html_escape_href, 1);
-	rb_define_method(rb_Markly_Node, "html_escape_html", rb_html_escape_html, 1);
+	Init_Markly_Node(Markly);
+	Init_Markly_Parser(Markly);
 
 	cmark_gfm_core_extensions_ensure_registered();
 }