commonmarker 2.10.0-arm-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35327c693dd53702f646b2cce40ee187a4c901340bc370f8e54285acc5a78526
+  data.tar.gz: f6913b5d0ff1907b1431dc1333b2a4af393d1ba9dcfe1b2fb13de0307e12570d
+SHA512:
+  metadata.gz: 4e14faf517356b5d4ad8d81d7d50676a34da3b0a21be3fef6ef9f5d2cd9afedeeafa9ecb8b35c8bf276eb006fdf4ec5380ec2f6707fb9b9eeef31bc56673eb87
+  data.tar.gz: 1d16283507055f8036c093e5db3408854f5b074ee8e15d79b4f0f17ade0e8874294f133a50aaefb1f514f3d9eb731e41bc9e66dcbeeeebd523961d1803be1df5

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Garen J. Torikian
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,385 @@
+# Commonmarker
+
+Ruby wrapper for Rust's [comrak](https://github.com/kivikakk/comrak) crate.
+
+It passes all of the CommonMark test suite, and is therefore spec-complete. It also includes extensions to the CommonMark spec as documented in the [GitHub Flavored Markdown spec](http://github.github.com/gfm/), such as support for tables, strikethroughs, and autolinking.
+
+> [!NOTE]
+> By default, the following extensions are enabled for end user convenience: `strikethrough`, `tagfilter`, `table`, `autolink`, `tasklist` (all from the [GFM spec](http://github.github.com/gfm/)), and `shortcodes`. The `syntax_highlighter` plugin is also enabled by default, using the `"base16-ocean.dark"` theme.
+>
+> For more information on the available options and extensions, see [the documentation below](#options-and-plugins).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'commonmarker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install commonmarker
+
+## Usage
+
+This gem expects to receive UTF-8 strings. Ensure your strings are the right encoding before passing them into `Commonmarker`.
+
+### Converting to HTML
+
+Call `to_html` on a string to convert it to HTML:
+
+```ruby
+require 'commonmarker'
+Commonmarker.to_html('"Hi *there*"', options: {
+    parse: { smart: true }
+})
+# => <p>“Hi <em>there</em>”</p>\n
+```
+
+(The second argument is optional--[see below](#options-and-plugins) for more information.)
+
+### Generating a document
+
+You can also parse a string to receive a `:document` node. You can then print that node to HTML, iterate over the children, and do other fun node stuff. For example:
+
+```ruby
+require 'commonmarker'
+
+doc = Commonmarker.parse("*Hello* world", options: {
+    parse: { smart: true }
+})
+puts(doc.to_html) # => <p><em>Hello</em> world</p>\n
+
+doc.walk do |node|
+  puts node.type # => [:document, :paragraph, :emph, :text, :text]
+end
+```
+
+(The second argument is optional--[see below](#options-and-plugins) for more information.)
+
+When it comes to modifying the document, you can perform the following operations:
+
+- `insert_before`
+- `insert_after`
+- `prepend_child`
+- `append_child`
+- `delete`
+
+You can also get the source position of a node by calling `source_position`:
+
+```ruby
+doc = Commonmarker.parse("*Hello* world")
+puts doc.first_child.first_child.source_position
+# => {:start_line=>1, :start_column=>1, :end_line=>1, :end_column=>7}
+```
+
+You can also modify the following attributes:
+
+- `url`
+- `title`
+- `header_level`
+- `list_type`
+- `list_start`
+- `list_tight`
+- `fence_info`
+- `alert_type`
+
+#### Example: Walking the AST
+
+You can use `walk` or `each` to iterate over nodes:
+
+- `walk` will iterate on a node and recursively iterate on a node's children.
+- `each` will iterate on a node's direct children, but no further.
+
+```ruby
+require 'commonmarker'
+
+# parse some string
+doc = Commonmarker.parse("# The site\n\n [GitHub](https://www.github.com)")
+
+# Walk tree and print out URLs for links
+doc.walk do |node|
+  if node.type == :link
+    printf("URL = %s\n", node.url)
+  end
+end
+# => URL = https://www.github.com
+
+# Transform links to regular text
+doc.walk do |node|
+  if node.type == :link
+    node.insert_before(node.first_child)
+    node.delete
+  end
+end
+# => <h1><a href=\"#the-site\"></a>The site</h1>\n<p>GitHub</p>\n
+```
+
+#### Example: Converting a document back into raw CommonMark
+
+You can use `to_commonmark` on a node to render it as raw text:
+
+```ruby
+require 'commonmarker'
+
+# parse some string
+doc = Commonmarker.parse("# The site\n\n [GitHub](https://www.github.com)")
+
+# Transform links to regular text
+doc.walk do |node|
+  if node.type == :link
+    node.insert_before(node.first_child)
+    node.delete
+  end
+end
+
+doc.to_commonmark
+# => # The site\n\nGitHub\n
+```
+
+### Reading and writing node content
+
+`string_content` reads and writes the text of nodes whose content is plain text (like `:text`, `:code`, and `:code_block`).
+
+`literal` reads and writes the raw string a node carries, for every node type that has one (like `:text`, `:code`, `:code_block`, `:html_block`, `:html_inline`, `:raw`, `:math`, and `:frontmatter`).
+
+The two exist separately because they mean different things. Rewriting `string_content` only ever swaps text for text. Rewriting `literal` on an `:html_block`, `:html_inline`, or `:raw` node writes markup that is emitted unescaped:
+
+```ruby
+doc = Commonmarker.parse("A <b>bold</b> claim")
+
+doc.walk do |node|
+  node.literal = "<i>" if node.type == :html_inline && node.literal == "<b>"
+end
+```
+
+Note that a `:frontmatter` node's literal includes its delimiters and trailing newlines, so anything you assign must include them too.
+
+## Options and plugins
+
+### Options
+
+Commonmarker accepts the same parse, render, and extensions options that comrak does, as a hash dictionary with symbol keys:
+
+```ruby
+Commonmarker.to_html('"Hi *there*"', options:{
+  parse: { smart: true },
+  render: { hardbreaks: false}
+})
+```
+
+Note that there is a distinction in comrak for "parse" options and "render" options, which are represented in the tables below. As well, if you wish to disable any-non boolean option, pass in `nil`.
+
+### Parse options
+
+| Name                         | Description                                                                                                                                 | Default |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
+| `smart`                      | Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation.                                                        | `false` |
+| `default_info_string`        | The default info string for fenced code blocks.                                                                                             | `""`    |
+| `relaxed_tasklist_matching`  | Enables relaxing of the tasklist extension matching, allowing any non-space to be used for the "checked" state instead of only `x` and `X`. | `false` |
+| `relaxed_autolinks`          | Enable relaxing of the autolink extension parsing, allowing links to be recognized when in brackets, as well as permitting any url scheme.  | `false` |
+| `leave_footnote_definitions` | Allow footnote definitions to remain in their original positions instead of being moved to the document's end (only affects AST)            | `false` |
+| `ignore_setext`              | Ignores setext-style headings.                                                                                                              | `false` |
+| `sourcepos_chars`            | Use character-based column tracking in source positions instead of byte-based. Relevant for multi-byte UTF-8 documents with `sourcepos`.    | `false` |
+
+### Render options
+
+| Name                 | Description                                                                                                              | Default      |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------ | ------------ |
+| `hardbreaks`         | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks.                   | `true`       |
+| `github_pre_lang`    | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                                           | `true`       |
+| `full_info_string`   | Gives info string data after a space in a `data-meta` attribute on code blocks.                                          | `false`      |
+| `width`              | The wrap column when outputting CommonMark.                                                                              | `80`         |
+| `unsafe`             | Allow rendering of raw HTML and potentially dangerous links.                                                             | `false`      |
+| `escape`             | Escape raw HTML instead of clobbering it.                                                                                | `false`      |
+| `sourcepos`          | Include source position attribute in HTML and XML output.                                                                | `false`      |
+| `escaped_char_spans` | Wrap escaped characters in span tags.                                                                                    | `true`       |
+| `ignore_empty_links` | Ignores empty links, leaving the Markdown text in place.                                                                 | `false`      |
+| `gfm_quirks`         | Outputs HTML with GFM-style quirks; namely, not nesting `<strong>` inlines.                                              | `false`      |
+| `prefer_fenced`      | Always output fenced code blocks, even where an indented one could be used.                                              | `false`      |
+| `tasklist_classes`   | Add CSS classes to the HTML output of the tasklist extension                                                             | `false`      |
+| `compact_html`       | Suppress newlines in pretty-printed HTML output.                                                                         | `false`      |
+| `alert_style`        | The style of alert output: `"specific"` (`<div class="markdown-alert">`) or `"semantic"` (`<aside class="admonition">`). | `"specific"` |
+
+As well, there are several extensions which you can toggle in the same manner:
+
+```ruby
+Commonmarker.to_html('"Hi *there*"', options: {
+    extension: { footnotes: true, description_lists: true },
+    render: { hardbreaks: false }
+})
+```
+
+### Extension options
+
+| Name                          | Description                                                                                                         | Default |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------- |
+| `strikethrough`               | Enables the [strikethrough extension](https://github.github.com/gfm/#strikethrough-extension-) from the GFM spec.   | `true`  |
+| `tagfilter`                   | Enables the [tagfilter extension](https://github.github.com/gfm/#disallowed-raw-html-extension-) from the GFM spec. | `true`  |
+| `table`                       | Enables the [table extension](https://github.github.com/gfm/#tables-extension-) from the GFM spec.                  | `true`  |
+| `autolink`                    | Enables the [autolink extension](https://github.github.com/gfm/#autolinks-extension-) from the GFM spec.            | `true`  |
+| `tasklist`                    | Enables the [task list extension](https://github.github.com/gfm/#task-list-items-extension-) from the GFM spec.     | `true`  |
+| `superscript`                 | Enables the superscript Comrak extension.                                                                           | `false` |
+| `header_ids`                  | Enables the header IDs Comrak extension. from the GFM spec.                                                         | `""`    |
+| `header_id_prefix_in_href`    | Also add the prefix to generated `href` attributes pointing to headers.                                             | `false` |
+| `footnotes`                   | Enables the footnotes extension per `cmark-gfm`.                                                                    | `false` |
+| `inline_footnotes`            | Enables the inline footnotes extension.                                                                             | `false` |
+| `description_lists`           | Enables the description lists extension.                                                                            | `false` |
+| `front_matter_delimiter`      | Enables the front matter extension.                                                                                 | `""`    |
+| `multiline_block_quotes`      | Enables the multiline block quotes extension.                                                                       | `false` |
+| `math_dollars`, `math_code`   | Enables the math extension.                                                                                         | `false` |
+| `math_latex`                  | Enables the math extension with LaTeX-style delimiters (`\(inline\)`, `\[display\]`).                               | `false` |
+| `shortcodes`                  | Enables the shortcodes extension.                                                                                   | `true`  |
+| `wikilinks_title_before_pipe` | Enables the wikilinks extension, placing the title before the dividing pipe.                                        | `false` |
+| `wikilinks_title_after_pipe`  | Enables the wikilinks extension, placing the title after the dividing pipe.                                         | `false` |
+| `underline`                   | Enables the underline extension.                                                                                    | `false` |
+| `spoiler`                     | Enables the spoiler extension.                                                                                      | `false` |
+| `greentext`                   | Enables the greentext extension.                                                                                    | `false` |
+| `subtext`                     | Enables the subtext extension.                                                                                      | `false` |
+| `subscript`                   | Enables the subscript extension.                                                                                    | `false` |
+| `alerts`                      | Enables the alerts extension.                                                                                       | `false` |
+| `cjk_friendly_emphasis`       | Enables the [CJK friendly emphasis](https://github.com/tats-u/markdown-cjk-friendly) extension.                     | `false` |
+| `highlight`                   | Enables highlighting via `==`                                                                                       | `false` |
+| `insert`                      | Enables the insert extension, rendering `++text++` as `<ins>text</ins>`.                                            | `false` |
+| `block_directive`             | Enables the block directive extension.                                                                              | `false` |
+
+For more information on these options, see [the comrak documentation](https://github.com/kivikakk/comrak#usage).
+
+### Plugins
+
+In addition to the possibilities provided by generic CommonMark rendering, Commonmarker also supports plugins as a means of
+providing further niceties.
+
+#### Syntax Highlighter Plugin
+
+The syntax highlighter plugin is **enabled by default**, using the `"base16-ocean.dark"` theme. It applies syntax highlighting to fenced code blocks that specify a language.
+
+The library comes with [a set of pre-existing themes](https://docs.rs/syntect/5.0.0/syntect/highlighting/struct.ThemeSet.html#implementations) for highlighting code:
+
+- `"base16-ocean.dark"`
+- `"base16-eighties.dark"`
+- `"base16-mocha.dark"`
+- `"base16-ocean.light"`
+- `"InspiredGitHub"`
+- `"Solarized (dark)"`
+- `"Solarized (light)"`
+
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+  ```
+CODE
+
+# pass in a theme name from a pre-existing set
+puts Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "InspiredGitHub" } })
+
+# <pre style="background-color:#ffffff;" lang="ruby"><code>
+# <span style="font-weight:bold;color:#a71d5d;">def </span><span style="font-weight:bold;color:#795da3;">hello
+# </span><span style="color:#62a35c;">puts </span><span style="color:#183691;">&quot;hello&quot;
+# </span><span style="font-weight:bold;color:#a71d5d;">end
+# </span>
+# </code></pre>
+````
+
+To disable this plugin, set the value to `nil`:
+
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+  ```
+CODE
+
+Commonmarker.to_html(code, plugins: { syntax_highlighter: nil })
+
+# <pre lang="ruby"><code>def hello
+#   puts &quot;hello&quot;
+# end
+# </code></pre>
+````
+
+To output CSS classes instead of `style` attributes, set the `theme` key to `""`:
+
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+CODE
+
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "" } })
+
+# <pre class="syntax-highlighting"><code><span class="source ruby"><span class="meta function ruby"><span class="keyword control def ruby">def</span></span><span class="meta function ruby"> # <span class="entity name function ruby">hello</span></span>
+#   <span class="support function builtin ruby">puts</span> <span class="string quoted double ruby"><span class="punctuation definition string begin ruby">&quot;</span>hello<span class="punctuation definition string end ruby">&quot;</span></span>
+# <span class="keyword control ruby">end</span>\n</span></code></pre>
+````
+
+To use a custom theme, you can provide a `path` to a directory containing `.tmtheme` files to load:
+
+```ruby
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "Monokai", path: "./themes" } })
+```
+
+## Output formats
+
+Commonmarker can currently only generate output in one format: HTML.
+
+### HTML
+
+```ruby
+puts Commonmarker.to_html('*Hello* world!')
+
+# <p><em>Hello</em> world!</p>
+```
+
+## Developing locally
+
+After cloning the repo:
+
+```
+script/bootstrap
+bundle exec rake compile
+```
+
+If there were no errors, you're done! Otherwise, make sure to follow the comrak dependency instructions.
+
+## Benchmarks
+
+```
+❯ bundle exec rake benchmark
+input size = 11064832 bytes
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+  Markly.render_html     1.000 i/100ms
+Markly::Node#to_html     1.000 i/100ms
+Commonmarker.to_html     1.000 i/100ms
+Commonmarker::Node.to_html
+                         1.000 i/100ms
+Kramdown::Document#to_html
+                         1.000 i/100ms
+Calculating -------------------------------------
+  Markly.render_html     15.606 (±25.6%) i/s -     71.000 in   5.047132s
+Markly::Node#to_html     15.692 (±25.5%) i/s -     72.000 in   5.095810s
+Commonmarker.to_html      4.482 (± 0.0%) i/s -     23.000 in   5.137680s
+Commonmarker::Node.to_html
+                          5.092 (±19.6%) i/s -     25.000 in   5.072220s
+Kramdown::Document#to_html
+                          0.379 (± 0.0%) i/s -      2.000 in   5.277770s
+
+Comparison:
+Markly::Node#to_html:       15.7 i/s
+  Markly.render_html:       15.6 i/s - same-ish: difference falls within error
+Commonmarker::Node.to_html:        5.1 i/s - 3.08x  slower
+Commonmarker.to_html:        4.5 i/s - 3.50x  slower
+Kramdown::Document#to_html:        0.4 i/s - 41.40x  slower
+```

data/lib/commonmarker/config.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  module Config
+    # For details, see
+    # https://github.com/kivikakk/comrak/blob/162ef9354deb2c9b4a4e05be495aa372ba5bb696/src/main.rs#L201
+    OPTIONS = {
+      parse: {
+        smart: false,
+        default_info_string: "",
+        relaxed_tasklist_matching: false,
+        relaxed_autolinks: false,
+        leave_footnote_definitions: false,
+        ignore_setext: false,
+        sourcepos_chars: false,
+      }.freeze,
+      render: {
+        hardbreaks: true,
+        github_pre_lang: true,
+        full_info_string: false,
+        width: 80,
+        unsafe: false,
+        escape: false,
+        sourcepos: false,
+        escaped_char_spans: true,
+        ignore_empty_links: false,
+        gfm_quirks: false,
+        prefer_fenced: false,
+        tasklist_classes: false,
+        compact_html: false,
+        alert_style: "specific",
+      }.freeze,
+      extension: {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        tasklist: true,
+        superscript: false,
+        header_ids: "",
+        header_id_prefix_in_href: false,
+        footnotes: false,
+        inline_footnotes: false,
+        description_lists: false,
+        front_matter_delimiter: "",
+        multiline_block_quotes: false,
+        math_dollars: false,
+        math_code: false,
+        math_latex: false,
+        shortcodes: true,
+        wikilinks_title_before_pipe: false,
+        wikilinks_title_after_pipe: false,
+        underline: false,
+        spoiler: false,
+        greentext: false,
+        subscript: false,
+        subtext: false,
+        alerts: false,
+        cjk_friendly_emphasis: false,
+        highlight: false,
+        insert: false,
+        block_directive: false,
+      }.freeze,
+      format: [:html].freeze,
+    }.freeze
+
+    PLUGINS = {
+      syntax_highlighter: {
+        theme: "base16-ocean.dark",
+        path: "",
+      }.freeze,
+    }.freeze
+
+    class << self
+      include Commonmarker::Utils
+
+      def process_options(options)
+        {
+          parse: process_parse_options(options[:parse].dup),
+          render: process_render_options(options[:render].dup),
+          extension: process_extension_options(options[:extension].dup),
+        }
+      end
+
+      def process_plugins(plugins)
+        {
+          syntax_highlighter: process_syntax_highlighter_plugin(plugins&.fetch(:syntax_highlighter, nil)),
+        }
+      end
+    end
+
+    [:parse, :render, :extension].each do |type|
+      define_singleton_method :"process_#{type}_options" do |options|
+        Commonmarker::Config::OPTIONS[type].each_with_object({}) do |(key, value), hash|
+          if options.nil? || !options.key?(key) # option not provided, use the default
+            hash[key] = value
+            next
+          end
+
+          if options[key].nil? # # option explicitly not included, remove it
+            options.delete(key)
+            next
+          end
+
+          hash[key] = fetch_kv(options, key, value, type)
+        end
+      end
+    end
+
+    define_singleton_method :process_syntax_highlighter_plugin do |options|
+      return if options.nil? # plugin explicitly nil, remove it
+
+      raise TypeError, "Expected a Hash for syntax_highlighter plugin, got #{options.class}" unless options.is_a?(Hash)
+      raise TypeError, "Expected a Hash for syntax_highlighter plugin, got nothing" if options.empty?
+
+      Commonmarker::Config::PLUGINS[:syntax_highlighter].merge(options)
+    end
+  end
+end

data/lib/commonmarker/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  module Constants
+    BOOLS = [true, false].freeze
+  end
+end

data/lib/commonmarker/extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+begin
+  # native precompiled gems package shared libraries in <gem_dir>/lib/commonmarker/<ruby_version>
+  # load the precompiled extension file
+  ruby_version = /\d+\.\d+/.match(RUBY_VERSION)
+  require_relative "#{ruby_version}/commonmarker"
+rescue LoadError
+  # fall back to the extension compiled upon installation.
+  # use "require" instead of "require_relative" because non-native gems will place C extension files
+  # in Gem::BasicSpecification#extension_dir after compilation (during normal installation), which
+  # is in $LOAD_PATH but not necessarily relative to this file (see nokogiri#2300)
+  require "commonmarker/commonmarker"
+end

data/lib/commonmarker/node/ast.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  class Node
+    class Ast
+    end
+  end
+end

data/lib/commonmarker/node/inspect.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "pp"
+
+module Commonmarker
+  class Node
+    module Inspect
+      PP_INDENT_SIZE = 2
+
+      def inspect
+        PP.pp(self, +"", Float::INFINITY)
+      end
+
+      # @param printer [PrettyPrint] pp
+      def pretty_print(printer)
+        printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", ">") do
+          printer.breakable
+
+          attrs = [
+            :source_position,
+            :string_content,
+            :url,
+            :title,
+            :header_level,
+            :list_type,
+            :list_start,
+            :list_tight,
+            :fence_info,
+            :alert_type,
+          ].filter_map do |name|
+            [name, __send__(name)] if respond_to?(name)
+          end
+
+          printer.seplist(attrs) do |name, value|
+            printer.text("#{name}=")
+            printer.pp(value)
+          end
+
+          if first_child
+            printer.breakable
+            printer.group(PP_INDENT_SIZE) do
+              children = []
+              node = first_child
+              while node
+                children << node
+                node = node.next_sibling
+              end
+              printer.text("children=")
+              printer.pp(children)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commonmarker/node.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "commonmarker/node/ast"
+require "commonmarker/node/inspect"
+
+module Commonmarker
+  class Node
+    include Enumerable
+    include Inspect
+
+    # Public: Whether this node responds to the given method.
+    #
+    # name        - A {Symbol} or {String} naming the method.
+    # include_all - A {Boolean} indicating whether to consider private methods.
+    #
+    # Returns a {Boolean}.
+    def respond_to?(name, include_all = false)
+      return false if node_supports?(name.to_sym) == false
+
+      super
+    end
+
+    # Public: An iterator that "walks the tree," descending into children recursively.
+    #
+    # blk - A {Proc} representing the action to take for each child
+    def walk(&block)
+      return enum_for(:walk) unless block
+
+      yield self
+      each do |child|
+        child.walk(&block)
+      end
+    end
+
+    # Public: Iterate over the children (if any) of the current pointer.
+    def each
+      return enum_for(:each) unless block_given?
+
+      child = first_child
+      while child
+        next_child = child.next_sibling
+        yield child
+        child = next_child
+      end
+    end
+
+    # Public: Converts a node to an HTML string.
+    #
+    # options - A {Hash} of render, parse, and extension options to transform the text.
+    # plugins - A {Hash} of additional plugins.
+    #
+    # Returns a {String} of HTML.
+    def to_html(options: Commonmarker::Config::OPTIONS, plugins: Commonmarker::Config::PLUGINS)
+      raise TypeError, "options must be a Hash; got a #{options.class}!" unless options.is_a?(Hash)
+
+      opts = Config.process_options(options)
+      plugins = Config.process_plugins(plugins)
+
+      node_to_html(render: opts[:render], parse: opts[:parse], extension: opts[:extension], plugins: plugins).force_encoding("utf-8")
+    end
+
+    # Public: Convert the node to a CommonMark string.
+    #
+    # options - A {Symbol} or {Array of Symbol}s indicating the render options
+    # plugins - A {Hash} of additional plugins.
+    #
+    # Returns a {String}.
+    def to_commonmark(options: Commonmarker::Config::OPTIONS, plugins: Commonmarker::Config::PLUGINS)
+      raise TypeError, "options must be a Hash; got a #{options.class}!" unless options.is_a?(Hash)
+
+      opts = Config.process_options(options)
+      plugins = Config.process_plugins(plugins)
+
+      node_to_commonmark(render: opts[:render], parse: opts[:parse], extension: opts[:extension], plugins: plugins).force_encoding("utf-8")
+    end
+  end
+end

data/lib/commonmarker/renderer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "set"
+require "stringio"
+
+module Commonmarker
+  class Renderer
+  end
+end

data/lib/commonmarker/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "commonmarker/constants"
+
+module Commonmarker
+  module Utils
+    include Commonmarker::Constants
+
+    def fetch_kv(options, key, value, type)
+      value_klass = value.class
+
+      if Constants::BOOLS.include?(value) && BOOLS.include?(options[key])
+        options[key]
+      elsif options[key].is_a?(value_klass)
+        options[key]
+      else
+        expected_type = Constants::BOOLS.include?(value) ? "Boolean" : value_klass.to_s
+        raise TypeError, "#{type} option `:#{key}` must be #{expected_type}; got #{options[key].class}"
+      end
+    end
+  end
+end

data/lib/commonmarker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  VERSION = "2.10.0"
+end

data/lib/commonmarker.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "commonmarker/extension"
+
+require "commonmarker/utils"
+require "commonmarker/node"
+require "commonmarker/config"
+require "commonmarker/renderer"
+require "commonmarker/version"
+
+module Commonmarker
+  class << self
+    # Public: Parses a CommonMark string into an HTML string.
+    #
+    # text - A {String} of text
+    # options - A {Hash} of render, parse, and extension options to transform the text.
+    #
+    # Returns the `parser` node.
+    def parse(text, options: Commonmarker::Config::OPTIONS)
+      raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+      raise TypeError, "text must be UTF-8 encoded; got #{text.encoding}!" unless text.encoding.name == "UTF-8"
+      raise TypeError, "options must be a Hash; got a #{options.class}!" unless options.is_a?(Hash)
+
+      opts = Config.process_options(options)
+
+      commonmark_parse(text, parse: opts.fetch(:parse, {}), render: opts.fetch(:render, {}), extension: opts.fetch(:extension, {}))
+    end
+
+    # Public: Parses a CommonMark string into an HTML string.
+    #
+    # text - A {String} of text
+    # options - A {Hash} of render, parse, and extension options to transform the text.
+    # plugins - A {Hash} of additional plugins.
+    #
+    # Returns a {String} of converted HTML.
+    def to_html(text, options: Commonmarker::Config::OPTIONS, plugins: Commonmarker::Config::PLUGINS)
+      raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+      raise TypeError, "text must be UTF-8 encoded; got #{text.encoding}!" unless text.encoding.name == "UTF-8"
+      raise TypeError, "options must be a Hash; got a #{options.class}!" unless options.is_a?(Hash)
+
+      opts = Config.process_options(options)
+      plugins = Config.process_plugins(plugins)
+
+      commonmark_to_html(text, parse: opts.fetch(:parse, {}), render: opts.fetch(:render, {}), extension: opts.fetch(:extension, {}), plugins: plugins)
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: commonmarker
+version: !ruby/object:Gem::Version
+  version: 2.10.0
+platform: arm-linux-gnu
+authors:
+- Garen Torikian
+- Ashe Connor
+bindir: exe
+cert_chain: []
+date: 2026-08-24 00:00:00.000000000 Z
+dependencies: []
+description: A fast, safe, extensible parser for CommonMark. This wraps the comrak
+  Rust crate.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/commonmarker.rb
+- lib/commonmarker/3.2/commonmarker.so
+- lib/commonmarker/3.3/commonmarker.so
+- lib/commonmarker/3.4/commonmarker.so
+- lib/commonmarker/4.0/commonmarker.so
+- lib/commonmarker/config.rb
+- lib/commonmarker/constants.rb
+- lib/commonmarker/extension.rb
+- lib/commonmarker/node.rb
+- lib/commonmarker/node/ast.rb
+- lib/commonmarker/node/inspect.rb
+- lib/commonmarker/renderer.rb
+- lib/commonmarker/utils.rb
+- lib/commonmarker/version.rb
+homepage: https://github.com/gjtorikian/commonmarker
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  funding_uri: https://github.com/sponsors/gjtorikian/
+  source_code_uri: https://github.com/gjtorikian/commonmarker
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: CommonMark parser and renderer. Written in Rust, wrapped in Ruby.
+test_files: []