markly 0.17.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b86cb2d3095458e69fe2d6fc2b9d6eb7dbee37b15edf5cc7064104ef12b5cb98
-  data.tar.gz: 1ddb2cac9ff79ee9fd2012e67949ddd5886930f6c5ecb28b54edf2eeffbbf110
+  metadata.gz: 2ef6552d303ea4620a87168fb130a802de075b747bcc737986b86083e46825bc
+  data.tar.gz: 1f9ac70b49a3170929bf56cfae562214b86fc59d58d3a07d42c14f74fbcd47c0
 SHA512:
-  metadata.gz: fbc478782839f1c5d20abd6f9697da6e870f4620873d1b1450b96e7f8e21c31f345d0461fbc6536da9f3a0b33b19ef7dd69a70c5f1edd40bc7e08b42cab66ac1
-  data.tar.gz: ef38f140dd12fbd5788e17f124f280fe25cb1a3af67963d0b8e1780b851adf75609f9da6f38e682ca4ff2a6f59d7d756dc5a7469ffaf76e99c9ea6a9f03b115f
+  metadata.gz: 7f3f69c8c4844f3c28621c6e301d4785c342d9660d305fc8f0452764e72784257f0a76ec608e5c0375171cf18455a46f0a6729e898eb805645ba8bea7c8f1ac3
+  data.tar.gz: 6c4c3505f5e0b47c927dd405d20e44b4c10043e6e2657b6ec12cbd7f02f8efaa56723f885bfa3daa33052e32e6d1e24a238d1fb7dec49e227ac9802ca54ec76f

data/context/extensions.md

@@ -0,0 +1,232 @@
+# Extensions
+
+This guide explains how to enable and use Markly's Markdown extensions.
+
+## Choosing a Markdown Dialect
+
+Markly parses standard CommonMark by default. Extensions change which syntax is
+recognized, so applications should enable them explicitly and consistently.
+This is especially important when several components parse or render the same
+document.
+
+Pass extension names as symbols using the `extensions:` keyword:
+
+``` ruby
+EXTENSIONS = %i[table tasklist strikethrough autolink].freeze
+
+html = Markly.render_html(markdown, extensions: EXTENSIONS)
+```
+
+When parsing and rendering separately, use the same configuration at both
+boundaries:
+
+``` ruby
+document = Markly.parse(markdown, extensions: EXTENSIONS)
+html = document.to_html(extensions: EXTENSIONS)
+```
+
+Extension names must be symbols. A string such as `"table"` raises `TypeError`,
+and an unknown symbol raises `ArgumentError`.
+
+## GitHub Flavored Markdown Extensions
+
+Markly includes the five syntax extensions defined by GitHub Flavored Markdown.
+None are enabled by default.
+
+### Tables
+
+The `:table` extension recognizes a paragraph followed by a delimiter row as a
+table. Colons in the delimiter row specify column alignment:
+
+``` ruby
+markdown = <<~MARKDOWN
+	| Package | Status |
+	| :--- | ---: |
+	| Markly | Ready |
+MARKDOWN
+
+document = Markly.parse(markdown, extensions: [:table])
+table = document.first_child
+
+table.type
+# => :table
+
+table.table_alignments
+# => [:left, :right]
+```
+
+The table AST contains `:table`, `:table_header`, `:table_row`, and
+`:table_cell` nodes. By default, HTML rendering uses `align` attributes for
+aligned cells. Pass `Markly::TABLE_PREFER_STYLE_ATTRIBUTES` when rendering to
+use `style="text-align: ..."` instead:
+
+``` ruby
+document.to_html(
+	flags: Markly::TABLE_PREFER_STYLE_ATTRIBUTES,
+	extensions: [:table],
+)
+```
+
+### Task Lists
+
+The `:tasklist` extension recognizes checked and unchecked list items:
+
+``` markdown
+- [x] Parse Markdown
+- [ ] Render HTML
+```
+
+Task-list state is available on the list-item node and can be changed before
+rendering:
+
+``` ruby
+document = Markly.parse("- [x] Parse Markdown", extensions: [:tasklist])
+item = document.first_child.first_child
+
+item.tasklist_item_checked?
+# => true
+
+item.tasklist_item_checked = false
+```
+
+### Strikethrough
+
+The `:strikethrough` extension renders strikethrough text using `<del>`:
+
+``` ruby
+Markly.render_html("~~obsolete~~", extensions: [:strikethrough])
+# => "<p><del>obsolete</del></p>\n"
+```
+
+Pass `Markly::STRIKETHROUGH_DOUBLE_TILDE` while parsing to accept only spans
+surrounded by exactly two tildes. This is useful when compatibility requires
+single or longer runs of tildes to remain literal:
+
+``` ruby
+Markly.render_html(
+	"~one~ ~~two~~ ~~~three~~~",
+	flags: Markly::STRIKETHROUGH_DOUBLE_TILDE,
+	extensions: [:strikethrough],
+)
+# => "<p>~one~ <del>two</del> ~~~three~~~</p>\n"
+```
+
+### Autolinks
+
+The `:autolink` extension turns plain URLs and email addresses into links
+without requiring angle brackets or Markdown link syntax:
+
+``` ruby
+Markly.render_html(
+	"Visit https://socketry.io or email hello@example.com.",
+	extensions: [:autolink],
+)
+```
+
+Use this extension when rendering prose where authors expect GitHub-style link
+detection. Leave it disabled when plain URL-like text must remain unchanged.
+
+### Tag Filtering
+
+The `:tagfilter` extension escapes the raw HTML tags prohibited by the GitHub
+Flavored Markdown specification. It is typically combined with
+`Markly::UNSAFE`, which otherwise permits raw HTML:
+
+``` ruby
+Markly.render_html(
+	"<script>alert('no')</script><strong>yes</strong>",
+	flags: Markly::UNSAFE,
+	extensions: [:tagfilter],
+)
+```
+
+Tag filtering is not a general-purpose HTML sanitizer. It filters the specific
+tag names required by the GFM specification, while other raw HTML remains
+available when `Markly::UNSAFE` is enabled. Sanitize untrusted HTML separately
+when the application requires a stricter policy.
+
+## Markly Syntax Features
+
+Markly also provides syntax features that are not named GFM extensions. Enable
+these with parser flags rather than adding names to `extensions:`.
+
+### Front Matter
+
+`Markly::FRONT_MATTER` recognizes a `---` delimited block only at the beginning
+of a document:
+
+``` ruby
+markdown = <<~MARKDOWN
+	--- yaml
+	title: Extensions
+	---
+	# Document
+MARKDOWN
+
+document = Markly.parse(markdown, flags: Markly::FRONT_MATTER)
+front_matter = document.first_child
+
+front_matter.type
+# => :front_matter
+
+front_matter.string_content
+# => "title: Extensions\n"
+
+front_matter.code_info
+# => "yaml"
+```
+
+Front matter is omitted from HTML and plain-text output. Markly exposes its raw
+contents but does not interpret YAML, TOML, or any other format. Treat the
+contents as untrusted input and parse them according to the application's own
+policy.
+
+The closing delimiter must be an exact `---` line. If it is missing, the rest
+of the document belongs to the front-matter node.
+
+### Inline Code Information
+
+`Markly::INLINE_CODE_INFO` recognizes a language prefix immediately before an
+inline code span:
+
+``` ruby
+document = Markly.parse(
+	"ruby:`Object.new`",
+	flags: Markly::INLINE_CODE_INFO,
+)
+code = document.first_child.first_child
+
+code.code_info
+# => "ruby"
+
+code.code_language
+# => "ruby"
+
+document.to_html
+# => "<p><code class=\"language-ruby\">Object.new</code></p>\n"
+```
+
+Without the flag, the prefix remains ordinary text. Inline code information is
+a single language token; richer code-block information belongs on a fenced code
+block instead.
+
+### Code Block Metadata
+
+`Node#code_info` is the general information-string accessor for fenced code
+blocks and front matter. `Node#code_language` returns the first token of that
+information string.
+
+For a fenced code block, `Node#fence` returns a {ruby Markly::Node::Fence}
+containing the fence character, length, and indentation:
+
+``` ruby
+block = Markly.parse("  ~~~~ ruby\n  Object.new\n  ~~~~").first_child
+
+block.code_info
+# => "ruby"
+
+block.fence
+# => #<struct Markly::Node::Fence character="~", length=4, indent=2>
+```
+
+Indented code blocks and other node types return `nil` from `Node#fence`.

data/context/getting-started.md

@@ -78,57 +78,21 @@ To have multiple options applied, `|` (or) the flags together:
 Markly.render_html("\"'Shelob' is my name.\"", flags: Markly::HARD_BREAKS|Markly::SOURCE_POSITION)
 ```
 
-Inline code language prefixes are opt-in. The language is available through
-`Node#code_info` and is rendered as a `language-...` class:
-
-``` ruby
-document = Markly.parse("ruby:`Object.new`", flags: Markly::INLINE_CODE_INFO)
-code = document.first_child.first_child
-
-code.code_info
-# => "ruby"
-
-code.code_language
-# => "ruby"
-
-document.to_html
-# => <p><code class="language-ruby">Object.new</code></p>
-```
-
-`Node#code_info` is also the general info-string accessor for fenced code
-blocks and front matter. `Node#code_language` returns the first token of that
-info string, while `Node#fence_info` remains available for compatibility on
-those block nodes.
-
-For a fenced code block, `Node#fence` returns a `Node::Fence` structure with
-the fence character, length, and indentation:
-
-``` ruby
-block = Markly.parse("  ~~~~ ruby\n  Object.new\n  ~~~~").first_child
-
-block.fence
-# => #<struct Markly::Node::Fence character="~", length=4, indent=2>
-```
-
-Indented code blocks and other node types return `nil`.
-
 ## Extensions
 
-Both `render_html` and `parse` take an optional `extensions:` argument defining the extensions you want enabled as your CommonMark document is being processed:
+Markly parses standard CommonMark by default. GitHub Flavored Markdown syntax
+and Markly-specific syntax are opt-in so applications can choose their accepted
+Markdown dialect explicitly:
 
 ``` ruby
-Markly.render_html("<script>hi</script>", flags: Markly::UNSAFE, extensions: [:tagfilter])
+Markly.render_html(
+	"| Name | Status |\n| --- | --- |\n| Markly | Ready |",
+	extensions: [:table],
+)
 ```
 
-The documentation for these extensions are [defined in this spec](https://github.github.com/gfm/), and the rationale is provided [in this blog post](https://githubengineering.com/a-formal-spec-for-github-markdown/).
-
-The available extensions are:
-
-  - `:table` - This provides support for tables.
-  - `:tasklist` - This provides support for task list items.
-  - `:strikethrough` - This provides support for strikethroughs.
-  - `:autolink` - This provides support for automatically converting URLs to anchor tags.
-  - `:tagfilter` - This escapes [several "unsafe" HTML tags](https://github.github.com/gfm/#disallowed-raw-html-extension-), causing them to not have any effect.
+See [Extensions](../extensions/index) for the supported extensions, related
+flags, and generated AST.
 
 ## Developing Locally
 

data/context/index.yaml

@@ -10,6 +10,9 @@ files:
 - path: getting-started.md
   title: Getting Started
   description: This guide explains now to install and use Markly.
+- path: extensions.md
+  title: Extensions
+  description: This guide explains how to enable and use Markly's Markdown extensions.
 - path: abstract-syntax-tree.md
   title: Abstract Syntax Tree
   description: This guide explains how to use Markly's abstract syntax tree (AST)

data/ext/markly/cmark-gfm-extension_api.h

@@ -264,6 +264,10 @@ typedef void (*cmark_opaque_free_func) (cmark_syntax_extension *extension,
                                         cmark_mem *mem,
                                         cmark_node *node);
 
+typedef void (*cmark_opaque_copy_func)(cmark_syntax_extension *extension,
+                                       cmark_mem *mem, cmark_node *node,
+                                       cmark_node *source);
+
 /** Free a cmark_syntax_extension.
  */
 CMARK_GFM_EXPORT
@@ -406,6 +410,12 @@ CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
                                                  cmark_opaque_free_func func);
 
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_opaque_copy_func(
+    cmark_syntax_extension *extension, cmark_opaque_copy_func func);
+
 /** See the documentation for 'cmark_syntax_extension'
  */
 CMARK_GFM_EXPORT

data/ext/markly/cmark-gfm.h

@@ -196,6 +196,12 @@ CMARK_GFM_EXPORT cmark_node *cmark_node_new_with_mem_and_ext(cmark_node_type typ
                                                 cmark_mem *mem,
                                                 cmark_syntax_extension *extension);
 
+/** Creates an independent deep copy of 'node' and all its children.
+ * User data is not copied. Returns NULL when extension-specific node data
+ * cannot be copied.
+ */
+CMARK_GFM_EXPORT cmark_node *cmark_node_clone(cmark_node *node);
+
 /** Frees the memory allocated for a node and any children.
  */
 CMARK_GFM_EXPORT void cmark_node_free(cmark_node *node);

data/ext/markly/extensions/table.c

@@ -842,6 +842,29 @@ static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem, cmark_node
   }
 }
 
+static void opaque_copy(cmark_syntax_extension *self, cmark_mem *mem,
+                        cmark_node *node, cmark_node *source) {
+  if (node->type == CMARK_NODE_TABLE) {
+    node_table *table = (node_table *)node->as.opaque;
+    node_table *source_table = (node_table *)source->as.opaque;
+
+    table->n_columns = source_table->n_columns;
+    table->n_rows = source_table->n_rows;
+    table->n_nonempty_cells = source_table->n_nonempty_cells;
+
+    if (source_table->alignments) {
+      table->alignments = mem->calloc(source_table->n_columns, sizeof(uint8_t));
+      memcpy(table->alignments, source_table->alignments,
+             source_table->n_columns * sizeof(uint8_t));
+    }
+  } else if (node->type == CMARK_NODE_TABLE_ROW) {
+    *(node_table_row *)node->as.opaque = *(node_table_row *)source->as.opaque;
+  } else if (node->type == CMARK_NODE_TABLE_CELL) {
+    mem->free(node->as.opaque);
+    node->as.cell_index = source->as.cell_index;
+  }
+}
+
 static int escape(cmark_syntax_extension *self, cmark_node *node, int c) {
   return
     node->type != CMARK_NODE_TABLE &&
@@ -867,6 +890,7 @@ cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension_set_html_render_func(self, html_render);
   cmark_syntax_extension_set_opaque_alloc_func(self, opaque_alloc);
   cmark_syntax_extension_set_opaque_free_func(self, opaque_free);
+  cmark_syntax_extension_set_opaque_copy_func(self, opaque_copy);
   cmark_syntax_extension_set_commonmark_escape_func(self, escape);
   CMARK_NODE_TABLE = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_ROW = cmark_syntax_extension_add_node(0);

data/ext/markly/html.c

@@ -303,7 +303,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
 
   case CMARK_NODE_PARAGRAPH:
     parent = cmark_node_parent(node);
-    grandparent = cmark_node_parent(parent);
+    grandparent = parent ? cmark_node_parent(parent) : NULL;
     if (grandparent != NULL && grandparent->type == CMARK_NODE_LIST) {
       tight = grandparent->as.list.tight;
     } else {
@@ -316,7 +316,8 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_putc(html, '>');
       } else {
-        if (parent->type == CMARK_NODE_FOOTNOTE_DEFINITION && node->next == NULL) {
+        if (parent && parent->type == CMARK_NODE_FOOTNOTE_DEFINITION &&
+            node->next == NULL) {
           cmark_strbuf_putc(html, ' ');
           S_put_footnote_backref(renderer, html, parent);
         }

data/ext/markly/markly.c

@@ -271,6 +271,21 @@ static VALUE Markly_Node_new(VALUE self, VALUE type) {
 	return Markly_Node_wrap(node);
 }
 
+/*
+ * 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;
 	
@@ -1273,6 +1288,7 @@ static void Init_Markly_Node(VALUE Markly) {
 	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);
 

data/ext/markly/node.c

@@ -145,6 +145,144 @@ cmark_node *cmark_node_new(cmark_node_type type) {
   return cmark_node_new_with_ext(type, NULL);
 }
 
+static cmark_chunk S_clone_chunk(cmark_mem *mem, const cmark_chunk *source) {
+  cmark_chunk clone = {NULL, source->len, 1};
+  clone.data = (unsigned char *)mem->calloc(source->len + 1, 1);
+  if (source->len > 0) {
+    memcpy(clone.data, source->data, source->len);
+  }
+  return clone;
+}
+
+static cmark_node *S_clone_node(cmark_node *node) {
+  cmark_mem *mem = NODE_MEM(node);
+  cmark_node *clone = cmark_node_new_with_mem_and_ext(
+      (cmark_node_type)node->type, mem, node->extension);
+
+  if (!clone) {
+    return NULL;
+  }
+
+  cmark_strbuf_set(&clone->content, node->content.ptr, node->content.size);
+  clone->start_line = node->start_line;
+  clone->start_column = node->start_column;
+  clone->end_line = node->end_line;
+  clone->end_column = node->end_column;
+  clone->internal_offset = node->internal_offset;
+  clone->flags = node->flags;
+  clone->footnote = node->footnote;
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    clone->as.heading = node->as.heading;
+    break;
+  case CMARK_NODE_LIST:
+  case CMARK_NODE_ITEM:
+    clone->as.list = node->as.list;
+    break;
+  case CMARK_NODE_CODE_BLOCK:
+  case CMARK_NODE_FRONT_MATTER:
+  case CMARK_NODE_CODE:
+    clone->as.code = node->as.code;
+    clone->as.code.info = S_clone_chunk(mem, &node->as.code.info);
+    clone->as.code.literal = S_clone_chunk(mem, &node->as.code.literal);
+    break;
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_FOOTNOTE_REFERENCE:
+  case CMARK_NODE_FOOTNOTE_DEFINITION:
+    clone->as.literal = S_clone_chunk(mem, &node->as.literal);
+    break;
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    clone->as.link.url = S_clone_chunk(mem, &node->as.link.url);
+    clone->as.link.title = S_clone_chunk(mem, &node->as.link.title);
+    break;
+  case CMARK_NODE_CUSTOM_BLOCK:
+  case CMARK_NODE_CUSTOM_INLINE:
+    clone->as.custom.on_enter = S_clone_chunk(mem, &node->as.custom.on_enter);
+    clone->as.custom.on_exit = S_clone_chunk(mem, &node->as.custom.on_exit);
+    break;
+  default:
+    break;
+  }
+
+  if (node->extension && node->extension->opaque_alloc_func) {
+    if (!node->extension->opaque_copy_func) {
+      cmark_node_free(clone);
+      return NULL;
+    }
+
+    node->extension->opaque_copy_func(node->extension, mem, clone, node);
+  }
+
+  for (cmark_node *child = node->first_child; child; child = child->next) {
+    cmark_node *child_clone = S_clone_node(child);
+    if (!child_clone) {
+      cmark_node_free(clone);
+      return NULL;
+    }
+
+    if (!cmark_node_append_child(clone, child_clone)) {
+      cmark_node_free(child_clone);
+      cmark_node_free(clone);
+      return NULL;
+    }
+  }
+
+  return clone;
+}
+
+static cmark_node *S_find_clone(cmark_node *source, cmark_node *clone,
+                                cmark_node *target) {
+  if (source == target) {
+    return clone;
+  }
+
+  cmark_node *source_child = source->first_child;
+  cmark_node *clone_child = clone->first_child;
+  while (source_child && clone_child) {
+    cmark_node *result = S_find_clone(source_child, clone_child, target);
+    if (result) {
+      return result;
+    }
+    source_child = source_child->next;
+    clone_child = clone_child->next;
+  }
+
+  return NULL;
+}
+
+static void S_clone_footnote_links(cmark_node *source, cmark_node *clone,
+                                   cmark_node *source_root,
+                                   cmark_node *clone_root) {
+  if (source->parent_footnote_def) {
+    clone->parent_footnote_def =
+        S_find_clone(source_root, clone_root, source->parent_footnote_def);
+  }
+
+  cmark_node *source_child = source->first_child;
+  cmark_node *clone_child = clone->first_child;
+  while (source_child && clone_child) {
+    S_clone_footnote_links(source_child, clone_child, source_root, clone_root);
+    source_child = source_child->next;
+    clone_child = clone_child->next;
+  }
+}
+
+cmark_node *cmark_node_clone(cmark_node *node) {
+  if (!node) {
+    return NULL;
+  }
+
+  cmark_node *clone = S_clone_node(node);
+  if (clone) {
+    S_clone_footnote_links(node, clone, node, clone);
+  }
+  return clone;
+}
+
 static void free_node_as(cmark_node *node) {
   switch (node->type) {
     case CMARK_NODE_CODE_BLOCK:

data/ext/markly/syntax_extension.c

@@ -143,6 +143,11 @@ void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extensi
   extension->opaque_free_func = func;
 }
 
+void cmark_syntax_extension_set_opaque_copy_func(
+    cmark_syntax_extension *extension, cmark_opaque_copy_func func) {
+  extension->opaque_copy_func = func;
+}
+
 void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
                                                        cmark_commonmark_escape_func func) {
   extension->commonmark_escape_func = func;

data/ext/markly/syntax_extension.h

@@ -28,6 +28,7 @@ struct cmark_syntax_extension {
   cmark_postprocess_func          postprocess_func;
   cmark_opaque_alloc_func         opaque_alloc_func;
   cmark_opaque_free_func          opaque_free_func;
+  cmark_opaque_copy_func          opaque_copy_func;
   cmark_commonmark_escape_func    commonmark_escape_func;
 };
 

data/lib/markly/node.rb

@@ -20,15 +20,7 @@ module Markly
 		#
 		# @returns [Markly::Node] The duplicated node tree.
 		def dup
-			# This is a bit crazy, but it's the best I can come up with right now:
-			node = Markly.parse(self.to_markdown)
-			
-			# If we aren't duplicating a document, we return `first_child` as the root will be a document node:
-			if self.type == :document
-				return node
-			else
-				return node.first_child
-			end
+			_dup
 		end
 		
 		# Walk the node tree recursively.

data/lib/markly/version.rb

@@ -9,5 +9,5 @@
 # @namespace
 module Markly
 	# @constant [String] The version of the Markly gem.
-	VERSION = "0.17.0"
+	VERSION = "0.18.1"
 end

data/readme.md

@@ -16,6 +16,8 @@ Please see the [project documentation](https://socketry.github.io/markly/) for m
 
   - [Getting Started](https://socketry.github.io/markly/guides/getting-started/index) - This guide explains now to install and use Markly.
 
+  - [Extensions](https://socketry.github.io/markly/guides/extensions/index) - This guide explains how to enable and use Markly's Markdown extensions.
+
   - [Abstract Syntax Tree](https://socketry.github.io/markly/guides/abstract-syntax-tree/index) - This guide explains how to use Markly's abstract syntax tree (AST) to parse and manipulate Markdown documents.
 
   - [Headings](https://socketry.github.io/markly/guides/headings/index) - This guide explains how to work with headings in Markly, including extracting them for navigation and handling duplicate heading text.
@@ -24,6 +26,10 @@ Please see the [project documentation](https://socketry.github.io/markly/) for m
 
 Please see the [project releases](https://socketry.github.io/markly/releases/index) for all releases.
 
+### v0.18.0
+
+  - Preserve complete node and extension metadata when duplicating node trees.
+
 ### v0.17.0
 
   - Add opt-in language prefixes for inline code spans with `Markly::INLINE_CODE_INFO`, expose code metadata through `Node#code_info`, and provide `Node#code_language` as a convenient language accessor.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v0.18.0
+
+  - Preserve complete node and extension metadata when duplicating node trees.
+
 ## v0.17.0
 
   - Add opt-in language prefixes for inline code spans with `Markly::INLINE_CODE_INFO`, expose code metadata through `Node#code_info`, and provide `Node#code_language` as a convenient language accessor.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markly
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.1
 platform: ruby
 authors:
 - Garen Torikian
@@ -65,6 +65,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - context/abstract-syntax-tree.md
+- context/extensions.md
 - context/getting-started.md
 - context/headings.md
 - context/index.yaml