gitlab-glfm-markdown 0.0.24-x86_64-linux-musl

data/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2011-present GitLab B.V.
+
+Portions of this software are licensed as follows:
+
+* All content residing under the "doc/" directory of this repository is licensed under "Creative Commons: CC BY-SA 4.0 license".
+* All content that resides under the "ee/" directory of this repository, if that directory exists, is licensed under the license defined in "ee/LICENSE".
+* All content that resides under the "jh/" directory of this repository, if that directory exists, is licensed under the license defined in "jh/LICENSE".
+* All client-side JavaScript (when served directly or after being compiled, arranged, augmented, or combined), is licensed under the "MIT Expat" license.
+* All third party components incorporated into the GitLab Software are licensed under the original license provided by the owner of the applicable component.
+* Content outside of the above mentioned directories or restrictions above is available under the "MIT Expat" license as defined below.
+
+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,109 @@
+# GitLab Flavored Markdown
+
+[![Pipeline status](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/badges/main/pipeline.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/commits/main)
+[![Latest Release](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/badges/release.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/releases)
+
+Implements GLFM (as used by GitLab) using the Rust-based markdown parser [comrak](https://github.com/kivikakk/comrak)
+and providing a Ruby interface.\
+_Currently using `comrak 0.31.0`_.
+
+This project is still in constant flux, so interfaces and functionality can change at any time.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add gitlab-glfm-markdown
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install gitlab-glfm-markdown
+
+## Usage
+
+Try on command line:
+
+```
+rake compile
+bin/console
+
+GLFMMarkdown.to_html('# header', options: { sourcepos: true })
+```
+
+### Options
+
+| Option name                     | Description                                                                           |
+|---------------------------------|---------------------------------------------------------------------------------------|
+| `autolink`                      | Enable the `autolink` extension                                                       |
+| `description_lists`             | Enable the `description-lists` extension                                              |
+| `escape`                        | Escape raw HTML instead of clobbering it                                              |
+| `escape_char_spans`             | Wrap escaped characters in a `<span>` to allow any post-processing to recognize them  |
+| `figure_with_caption`           | Render the image as a figure element with the title as its caption                    |
+| `footnotes`                     | Enable the `footnotes` extension                                                      |
+| `full_info_string`              | Enable full info strings for code blocks                                              |
+| `gemojis`                       | Enable the `gemojis` extensions - translate gemojis into UTF-8 characters             |
+| `gfm_quirks`                    | Enables GFM-style quirks in output HTML, such as not nesting <strong> tags            |
+| `github_pre_lang`               | Use GitHub-style `<pre lang>` for code blocks                                         |
+| `greentext`                     | Enable the `greentext` extension - requires at least one space after a `>` character to generate a blockquote, and restarts blockquote nesting across unique lines of input |
+| `hardbreaks`                    | Treat newlines as hard line breaks                                                    |
+| `header_ids <PREFIX>`           | Enable the `header-id` extension, with the given ID prefix                            |
+| `ignore_empty_links`            | Ignore empty links in input                                                           |
+| `ignore_setext`                 | Ignore setext headings in input                                                       |
+| `math_code`                     | Enables `math code` extension, using math code syntax                                 |
+| `math_dollars`                  | Enables `math dollars` extension, using math dollar syntax                            |
+| `multiline_block_quotes`        | Enable the `multiline-block-quotes` extension                                         |
+| `relaxed_autolinks`             | Enable relaxing of autolink parsing, allowing links to be recognized when in brackets |
+| `relaxed_tasklist_character`    | Enable relaxing which character is allowed in tasklists                               |
+| `sourcepos`                     | Include source mappings in HTML attributes                                            |
+| `experimental_inline_sourcepos` | Include inline sourcepos in HTML output, which is known to have issues                |
+| `smart`                         | Use smart punctuation                                                                 |
+| `spoiler`                       | Enable the `spoiler` extension - use double vertical bars                             |
+| `strikethrough`                 | Enable the `strikethrough` extension                                                  |
+| `superscript`                   | Enable the `superscript` extension                                                    |
+| `table`                         | Enable the `table` extension                                                          |
+| `tagfilter`                     | Enable the `tagfilter` extension                                                      |
+| `tasklist`                      | Enable the `tasklist` extension                                                       |
+| `underline`                     | Enables the `underline` extension - use double underscores                            |
+| `unsafe`                        | Allow raw HTML and dangerous URLs                                                     |
+| `wikilinks_title_after_pipe`    | Enable the `wikilinks_title_after_pipe` extension                                     |
+| `wikilinks_title_before_pipe`   | Enable the `wikilinks_title_before_pipe` extension                                    |
+| `debug`                         | Show debug information                                                                |
+
+## Dingus / Demo
+
+A demo is running via GitLab Pages, and can be accessed at:
+
+https://gitlab-org.gitlab.io/ruby/gems/gitlab-glfm-markdown
+
+## Development
+
+A command line executable can be built for debugging.
+
+```
+cargo run --bin glfm_markdown --features="cli" -- --help
+cargo run --bin glfm_markdown --features="cli" -- --sourcepos
+```
+
+There is a VSCode workspace that allows you to `Debug executable`
+
+When developing another project locally and using `gitlab-glfm-markdown` by linking
+directly to the gem's source directory, make sure that you're using the same version
+of Ruby for the project and the gem. Otherwise you can see unexplained errors when
+calling into the gem.
+
+NOTE: This project generates a changelog automatically that gets attached to the release entry.
+The normal [GitLab changelog entry process](https://docs.gitlab.com/ee/development/changelog.html)
+should be followed.
+
+### Releasing a new version
+
+To release a new version, create a merge request and use the `Release` template, following it's instructions.
+
+Once merged, the new version with precompiled, native gems will automatically be
+published to [RubyGems](https://rubygems.org/gems/gitlab-glfm-markdown).
+
+## Contributing
+
+Bug reports and merge requests are welcome on GitLab at https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown.
+
+Please refer to [CONTRIBUTING](CONTRIBUTING.md) for more details.

data/ext/glfm_markdown/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "glfm_markdown"
+version = "0.0.24"
+edition = "2021"
+authors = ["digitalmoksha <bwalker@gitlab.com>"]
+description = "GitLab Flavored Markdown parser and formatter. 100% CommonMark-compatible. Experimental."
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[[bin]]
+name = "glfm_markdown"
+required-features = ["cli"]
+
+[dependencies]
+clap = { version = "4.0", optional = true, features = ["derive", "string"] }
+comrak = { version = "0.31.0", default-features = false, features = ["shortcodes"] }
+magnus = "0.6.2"
+rb-sys = { version = "0.9.86", default-features = false, features = ["stable-api-compiled-fallback"] }
+
+[features]
+cli = ["clap", "comrak/syntect"]

data/ext/glfm_markdown/extconf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('glfm_markdown/glfm_markdown') do |r|
+  r.auto_install_rust_toolchain = false
+end

data/ext/glfm_markdown/src/glfm.rs

@@ -0,0 +1,93 @@
+#[derive(Debug)]
+pub struct RenderOptions {
+    pub autolink: bool,
+    // pub default_info_string: String,
+    pub description_lists: bool,
+    pub escape: bool,
+    pub escaped_char_spans: bool,
+    pub figure_with_caption: bool,
+    pub footnotes: bool,
+    // pub front_matter_delimiter: String,
+    pub full_info_string: bool,
+    pub gemojis: bool,
+    pub gfm_quirks: bool,
+    pub github_pre_lang: bool,
+    pub greentext: bool,
+    pub hardbreaks: bool,
+    pub header_ids: Option<String>,
+    pub ignore_empty_links: bool,
+    pub ignore_setext: bool,
+    pub math_code: bool,
+    pub math_dollars: bool,
+    pub multiline_block_quotes: bool,
+    pub relaxed_autolinks: bool,
+    pub relaxed_tasklist_character: bool,
+    pub sourcepos: bool,
+    pub experimental_inline_sourcepos: bool,
+    pub smart: bool,
+    pub spoiler: bool,
+    pub strikethrough: bool,
+    pub subscript: bool,
+    pub superscript: bool,
+    // pub syntax_highlighting: String,
+    pub table: bool,
+    pub tagfilter: bool,
+    pub tasklist: bool,
+    pub underline: bool,
+    pub unsafe_: bool,
+    pub wikilinks_title_after_pipe: bool,
+    pub wikilinks_title_before_pipe: bool,
+
+    pub debug: bool,
+}
+
+pub fn render(text: String, options: RenderOptions) -> String {
+    render_comrak(text, options)
+}
+
+fn render_comrak(text: String, options: RenderOptions) -> String {
+    let mut comrak_options = comrak::ComrakOptions::default();
+
+    comrak_options.extension.autolink = options.autolink;
+    comrak_options.extension.description_lists = options.description_lists;
+    comrak_options.extension.footnotes = options.footnotes;
+    // comrak_options.extension.front_matter_delimiter = options.front_matter_delimiter;
+    comrak_options.extension.greentext = options.greentext;
+    comrak_options.extension.header_ids = options.header_ids;
+    comrak_options.extension.math_code = options.math_code;
+    comrak_options.extension.math_dollars = options.math_dollars;
+    comrak_options.extension.multiline_block_quotes = options.multiline_block_quotes;
+    comrak_options.extension.shortcodes = options.gemojis;
+    comrak_options.extension.spoiler = options.spoiler;
+    comrak_options.extension.strikethrough = options.strikethrough;
+    comrak_options.extension.subscript = options.subscript;
+    comrak_options.extension.superscript = options.superscript;
+    comrak_options.extension.table = options.table;
+    comrak_options.extension.tagfilter = options.tagfilter;
+    comrak_options.extension.tasklist = options.tasklist;
+    comrak_options.extension.underline = options.underline;
+    comrak_options.extension.wikilinks_title_after_pipe = options.wikilinks_title_after_pipe;
+    comrak_options.extension.wikilinks_title_before_pipe = options.wikilinks_title_before_pipe;
+
+    comrak_options.render.escape = options.escape;
+    comrak_options.render.escaped_char_spans = options.escaped_char_spans;
+    comrak_options.render.figure_with_caption = options.figure_with_caption;
+    comrak_options.render.full_info_string = options.full_info_string;
+    comrak_options.render.gfm_quirks = options.gfm_quirks;
+    comrak_options.render.github_pre_lang = options.github_pre_lang;
+    comrak_options.render.hardbreaks = options.hardbreaks;
+    comrak_options.render.ignore_empty_links = options.ignore_empty_links;
+    comrak_options.render.ignore_setext = options.ignore_setext;
+    comrak_options.render.sourcepos = options.sourcepos;
+    comrak_options.render.experimental_inline_sourcepos = options.experimental_inline_sourcepos;
+    // comrak_options.render.syntax_highlighting = options.syntax_highlighting;
+
+    comrak_options.render.unsafe_ = options.unsafe_;
+
+    // comrak_options.parse.default_info_string = options.default_info_string;
+    comrak_options.parse.relaxed_autolinks = options.relaxed_autolinks;
+    comrak_options.parse.relaxed_tasklist_matching = options.relaxed_tasklist_character;
+    comrak_options.parse.smart = options.smart;
+
+    comrak::markdown_to_html(&text, &comrak_options)
+}

data/ext/glfm_markdown/src/lib.rs

@@ -0,0 +1,69 @@
+use magnus::{define_module, function, prelude::*, Error, RHash, Symbol};
+
+mod glfm;
+use glfm::{render, RenderOptions};
+
+/// Lookup symbol in provided `RHash`. Returns `false` if the key is not present
+/// or value cannot be converted to a boolean.
+fn get_bool_opt(arg: &str, options: RHash) -> bool {
+    options.lookup(Symbol::new(arg)).unwrap_or_default()
+}
+
+fn get_string_opt(arg: &str, options: RHash) -> Option<String> {
+    options.lookup(Symbol::new(arg)).ok()
+}
+
+pub fn render_to_html_rs(text: String, options: RHash) -> String {
+    let render_options = RenderOptions {
+        autolink: get_bool_opt("autolink", options),
+        // default_info_string: get_string_opt("default_info_string", options),
+        description_lists: get_bool_opt("description_lists", options),
+        escape: get_bool_opt("escape", options),
+        escaped_char_spans: get_bool_opt("escaped_char_spans", options),
+        figure_with_caption: get_bool_opt("figure_with_caption", options),
+        footnotes: get_bool_opt("footnotes", options),
+        // front_matter_delimiter: get_string_opt("front_matter_delimiter", options),
+        full_info_string: get_bool_opt("full_info_string", options),
+        gemojis: get_bool_opt("gemojis", options),
+        gfm_quirks: get_bool_opt("gfm_quirks", options),
+        github_pre_lang: get_bool_opt("github_pre_lang", options),
+        greentext: get_bool_opt("greentext", options),
+        hardbreaks: get_bool_opt("hardbreaks", options),
+        header_ids: get_string_opt("header_ids", options),
+        ignore_empty_links: get_bool_opt("ignore_empty_links", options),
+        ignore_setext: get_bool_opt("ignore_setext", options),
+        math_code: get_bool_opt("math_code", options),
+        math_dollars: get_bool_opt("math_dollars", options),
+        multiline_block_quotes: get_bool_opt("multiline_block_quotes", options),
+        relaxed_autolinks: get_bool_opt("relaxed_autolinks", options),
+        relaxed_tasklist_character: get_bool_opt("relaxed_tasklist_character", options),
+        sourcepos: get_bool_opt("sourcepos", options),
+        experimental_inline_sourcepos: get_bool_opt("experimental_inline_sourcepos", options),
+        smart: get_bool_opt("smart", options),
+        spoiler: get_bool_opt("spoiler", options),
+        strikethrough: get_bool_opt("strikethrough", options),
+        subscript: get_bool_opt("subscript", options),
+        superscript: get_bool_opt("superscript", options),
+        // syntax_highlighting: get_string_opt("syntax_highlighting", options),
+        table: get_bool_opt("table", options),
+        tagfilter: get_bool_opt("tagfilter", options),
+        tasklist: get_bool_opt("tasklist", options),
+        underline: get_bool_opt("underline", options),
+        unsafe_: get_bool_opt("unsafe", options),
+        wikilinks_title_after_pipe: get_bool_opt("wikilinks_title_after_pipe", options),
+        wikilinks_title_before_pipe: get_bool_opt("wikilinks_title_before_pipe", options),
+
+        debug: get_bool_opt("debug", options),
+    };
+
+    render(text, render_options)
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("GLFMMarkdown")?;
+
+    module.define_singleton_method("render_to_html_rs", function!(render_to_html_rs, 2))?;
+
+    Ok(())
+}

data/ext/glfm_markdown/src/main.rs

@@ -0,0 +1,227 @@
+mod glfm;
+use glfm::{render, RenderOptions};
+use std::io::Read;
+use std::io::Write;
+
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// CommonMark file(s) to parse; or standard input if none passed
+    #[arg(value_name = "FILE")]
+    file: Option<String>,
+
+    /// Enable 'autolink' extension
+    #[arg(long)]
+    autolink: bool,
+
+    /// Enable 'description-lists' extension
+    #[arg(long)]
+    description_lists: bool,
+
+    /// Escape raw HTML instead of clobbering it
+    #[arg(long)]
+    escape: bool,
+
+    /// Wrap escaped characters in a `<span>` to allow any post-processing to recognize them
+    #[arg(long)]
+    escaped_char_spans: bool,
+
+    /// Enable 'footnotes' extension
+    #[arg(long)]
+    footnotes: bool,
+
+    /// Ignore front-matter that starts and ends with the given string
+    // #[arg(long, value_name = "DELIMITER", allow_hyphen_values = true)]
+    // front_matter_delimiter: Option<String>,
+
+    /// Enable full info strings for code blocks
+    #[arg(long)]
+    full_info_string: bool,
+
+    /// Translate gemojis into UTF-8 characters
+    #[arg(long)]
+    gemojis: bool,
+
+    /// Enables GFM-style quirks in output HTML, such as not nesting <strong>
+    /// tags, which otherwise breaks CommonMark compatibility.
+    #[arg(long)]
+    gfm_quirks: bool,
+
+    /// Use GitHub-style <pre lang> for code blocks
+    #[arg(long)]
+    github_pre_lang: bool,
+
+    /// Requires at least one space after a `>` character to generate a blockquote,
+    /// and restarts blockquote nesting across unique lines of input
+    #[arg(long)]
+    greentext: bool,
+
+    /// Treat newlines as hard line breaks
+    #[arg(long)]
+    hardbreaks: bool,
+
+    /// Enable the 'header IDs` extension, with the given ID prefix
+    #[arg(long, value_name = "PREFIX")]
+    header_ids: Option<String>,
+
+    /// Ignore empty links in input.
+    #[arg(long)]
+    ignore_empty_links: bool,
+
+    /// Ignore setext headings in input.
+    #[arg(long)]
+    ignore_setext: bool,
+
+    /// Enables `math code` extension, using math code syntax
+    #[arg(long)]
+    math_code: bool,
+
+    /// Enables `math dollar` extension, using math dollar syntax
+    #[arg(long)]
+    math_dollars: bool,
+
+    /// Enable 'multiline block quotes' extension
+    #[arg(long)]
+    multiline_block_quotes: bool,
+
+    /// Write output to FILE instead of stdout
+    #[arg(short, long, value_name = "FILE")]
+    output: Option<String>,
+
+    /// Enable relaxing of autolink parsing, allowing links to be recognized when in brackets
+    #[arg(long)]
+    relaxed_autolinks: bool,
+
+    /// Enable relaxing which character is allowed in a tasklists
+    #[arg(long)]
+    relaxed_tasklist_character: bool,
+
+    /// Include source mappings in HTML attributes
+    #[arg(long)]
+    sourcepos: bool,
+
+    /// Include inline sourcepos in HTML output, which is known to have issues.
+    #[arg(long)]
+    experimental_inline_sourcepos: bool,
+
+    /// Use smart punctuation
+    #[arg(long)]
+    smart: bool,
+
+    /// Enables spoilers using double vertical bars
+    #[arg(long)]
+    spoiler: bool,
+
+    /// Enable 'strikethrough' extension
+    #[arg(long)]
+    strikethrough: bool,
+
+    /// Enable 'subscript' extension
+    #[arg(long)]
+    subscript: bool,
+
+    /// Enable 'superscript' extension
+    #[arg(long)]
+    superscript: bool,
+
+    /// Syntax highlighting for codefence blocks. Choose a theme or 'none' for disabling.
+    // #[arg(long, value_name = "THEME", default_value = "base16-ocean.dark")]
+    // syntax_highlighting: String,
+
+    /// Enable 'table' extension
+    #[arg(long)]
+    table: bool,
+
+    /// Enable 'tagfilter' extension
+    #[arg(long)]
+    tagfilter: bool,
+
+    /// Enable 'tasklist' extension
+    #[arg(long)]
+    tasklist: bool,
+
+    /// Enables underlines using double underscores
+    #[arg(long)]
+    underline: bool,
+
+    /// Allow raw HTML and dangerous URLs
+    #[arg(long = "unsafe")]
+    unsafe_: bool,
+
+    /// Enable 'wikilink_title_after_pipe' extension
+    #[arg(long)]
+    wikilinks_title_after_pipe: bool,
+
+    /// Enable 'wikilink_title_before_pipe' extension
+    #[arg(long)]
+    wikilinks_title_before_pipe: bool,
+
+    /// Show debug information
+    #[arg(long)]
+    debug: bool,
+}
+
+fn main() {
+    let mut s: Vec<u8> = Vec::with_capacity(2048);
+    let cli = Args::parse();
+
+    match cli.file {
+        None => {
+            std::io::stdin().read_to_end(&mut s).unwrap();
+        }
+        Some(fs) => {
+            s = std::fs::read(fs).unwrap();
+        }
+    };
+
+    let source = String::from_utf8_lossy(&s);
+    let options = RenderOptions {
+        autolink: cli.autolink,
+        // default_info_string:
+        description_lists: cli.description_lists,
+        escape: cli.escape,
+        escaped_char_spans: cli.escaped_char_spans,
+        footnotes: cli.footnotes,
+        // front_matter_delimiter:
+        full_info_string: cli.full_info_string,
+        gemojis: cli.gemojis,
+        gfm_quirks: cli.gfm_quirks,
+        github_pre_lang: cli.github_pre_lang,
+        greentext: cli.greentext,
+        hardbreaks: cli.hardbreaks,
+        header_ids: cli.header_ids,
+        ignore_empty_links: cli.ignore_empty_links,
+        ignore_setext: cli.ignore_setext,
+        math_code: cli.math_code,
+        math_dollars: cli.math_dollars,
+        multiline_block_quotes: cli.multiline_block_quotes,
+        relaxed_autolinks: cli.relaxed_autolinks,
+        relaxed_tasklist_character: cli.relaxed_tasklist_character,
+        sourcepos: cli.sourcepos,
+        experimental_inline_sourcepos: cli.experimental_inline_sourcepos,
+        smart: cli.smart,
+        spoiler: cli.spoiler,
+        strikethrough: cli.strikethrough,
+        subscript: cli.subscript,
+        superscript: cli.superscript,
+        // syntax_highlighting:
+        table: cli.table,
+        tagfilter: cli.tagfilter,
+        tasklist: cli.tasklist,
+        underline: cli.underline,
+        unsafe_: cli.unsafe_,
+        wikilinks_title_after_pipe: cli.wikilinks_title_after_pipe,
+        wikilinks_title_before_pipe: cli.wikilinks_title_before_pipe,
+        debug: cli.debug,
+    };
+
+    let result = render(source.to_string(), options);
+
+    if let Some(output_filename) = cli.output {
+        std::fs::write(output_filename, &result).unwrap();
+    } else {
+        std::io::stdout().write_all(result.as_bytes()).unwrap();
+    };
+}

data/lib/glfm_markdown/loader.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+def load_rust_extension
+  ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
+  require "glfm_markdown/#{ruby_version}/glfm_markdown"
+rescue LoadError
+  require 'glfm_markdown/glfm_markdown'
+end

data/lib/glfm_markdown/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GLFMMarkdown
+  VERSION = '0.0.24'
+end

data/lib/glfm_markdown.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'glfm_markdown/version'
+require_relative 'glfm_markdown/loader'
+
+load_rust_extension
+
+module GLFMMarkdown
+  GLFM_DEFAULT_OPTIONS = {
+    autolink: true,
+    escaped_char_spans: false,
+    footnotes: true,
+    full_info_string: true,
+    gfm_quirks: true,
+    github_pre_lang: false,
+    hardbreaks: false,
+    math_code: false,
+    math_dollars: false,
+    multiline_block_quotes: true,
+    relaxed_autolinks: false,
+    sourcepos: true,
+    experimental_inline_sourcepos: true,
+    smart: false,
+    strikethrough: true,
+    table: true,
+    tagfilter: false,
+    tasklist: true,
+    unsafe: true,
+
+    debug: false
+  }.freeze
+
+  class << self
+    def to_html(markdown, options: {})
+      raise TypeError, 'markdown must be a String' unless markdown.is_a?(String)
+      raise TypeError, 'markdown must be UTF-8 encoded' unless markdown.encoding.name == "UTF-8"
+      raise TypeError, 'options must be a Hash' unless options.is_a?(Hash)
+
+      default_options = options[:glfm] ? GLFM_DEFAULT_OPTIONS : {}
+
+      # if you need to modify `options`, use `.merge` as `options` could be frozen
+      options = options.merge(unsafe: true) if options[:tagfilter]
+
+      render_to_html_rs(markdown, default_options.merge(options))
+    end
+  end
+end