marktip 0.2.0__tar.gz → 0.3.0__tar.gz

{marktip-0.2.0 → marktip-0.3.0}/CMakeLists.txt

@@ -7,7 +7,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 if(NOT DEFINED SKBUILD_PROJECT_VERSION)
-  set(SKBUILD_PROJECT_VERSION "0.2.0")
+  set(SKBUILD_PROJECT_VERSION "0.3.0")
 endif()
 
 set(PYBIND11_FINDPYTHON ON)

marktip-0.3.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: marktip
+Version: 0.3.0
+Summary: Fast C++/MD4C Markdown parser and canonical Markdown serializer for Tiptap-style JSON
+Keywords: markdown,tiptap,md4c,parser
+Author: Saneaven (Minjae Kyung)
+License-Expression: MIT
+License-File: LICENSE
+License-File: third_party/md4c/LICENSE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Description-Content-Type: text/markdown
+
+# marktip
+
+Fast C++/MD4C Markdown conversion for Tiptap-style JSON.
+
+## Installation
+
+```bash
+python -m pip install marktip
+```
+
+Release wheels are built for common CPython versions on Linux, macOS, and
+Windows. If a wheel is not available for a platform, pip can build from the
+source distribution with a C++17 compiler and standard Python build tooling.
+
+## Usage
+
+```python
+import marktip as tm
+
+doc = tm.from_markdown("# Hello")
+ast = doc.to_dict()
+markdown = doc.to_markdown()
+
+doc = tm.from_dict(ast)
+```
+
+`from_markdown` follows GFM/CommonMark by default. Pass `cjk_friendly=True` to
+relax the emphasis and strikethrough rules so delimiters next to CJK text still
+open and close (e.g. `**볼드**은` parses as bold), a non-standard extension that
+is off by default:
+
+```python
+doc = tm.from_markdown("**볼드**은 강조", cjk_friendly=True)
+```
+
+Strikethrough follows the GFM reference implementations (cmark-gfm/micromark):
+intra-word `~~` strikes (`a~~b~~c`), including next to CJK letters
+(`~~삭제~~은`). `cjk_friendly` still matters for `*`/`_`, and for `~` in
+punctuation-adjacent cases such as `~~"인용"~~라고`.
+
+Pass `html=False` to parse raw HTML as literal text instead of
+`htmlBlock`/`htmlInline` nodes. Content is preserved (the serializer escapes
+it), and `<br>` inside table cells still maps to `hardBreak` so marktip's own
+table output round-trips:
+
+```python
+doc = tm.from_markdown("a <u>x</u> b", html=False)
+# paragraph with the literal text "a <u>x</u> b"
+```
+
+marktip targets GFM core syntax and canonical Markdown output rather than
+byte-identical source preservation.
+
+## Schema enforcement
+
+The Tiptap-side schema is closed: every node/mark type must have a markdown
+mapping. `from_dict` rejects unknown types instead of silently dropping
+content, raising `marktip.UnknownTypeError` — a `ValueError` subclass with
+structured fields for programmatic relay:
+
+```python
+try:
+    tm.from_dict({"type": "doc", "content": [{"type": "callout"}]})
+except tm.UnknownTypeError as e:
+    e.type    # "callout"
+    e.kind    # "node" or "mark"
+    e.path    # "content[0]"
+    e.detail  # "unknown node type 'callout' at content[0]"
+```
+
+Known node types: `doc`, `paragraph`, `text`, `hardBreak`, `heading`,
+`blockquote`, `codeBlock`, `horizontalRule`, `bulletList`, `orderedList`,
+`listItem`, `taskList`, `taskItem`, `table`, `tableRow`, `tableHeader`,
+`tableCell`, `image`, `htmlBlock`, `htmlInline`. Known marks: `bold`,
+`italic`, `strike`, `code`, `link`.
+
+## Defined normalizations
+
+Markdown cannot represent every Tiptap document exactly. Rather than emitting
+markdown that reparses into a different structure, marktip applies these
+deterministic (and idempotent) normalizations at serialization time:
+
+- **Hard breaks in headings** — ATX headings are single-line, so a `hardBreak`
+  (or a literal newline carried over from setext input) inside a heading
+  serializes as a single space: `heading("a", hardBreak, "b")` → `# a b`.
+- **Multi-block table cells** — blocks inside a cell are joined with `<br>`
+  and the cell is flattened to one line; two paragraphs in a cell reparse as
+  one paragraph containing a `hardBreak`.
+- **Headerless tables** — GFM tables require a header row, so the first row is
+  always emitted as the header; a leading `tableCell` row reparses as
+  `tableHeader`.
+- **Heading levels** — clamped to 1–6 at serialization (`0` → `#`, `7` →
+  `######`).
+- **Emphasis boundary whitespace** — whitespace touching an emphasis delimiter
+  has no valid markdown form and is expelled outside the marks
+  (`bold("굵게 ")` → `**굵게** `), cf. prosemirror-markdown's
+  `expelEnclosingWhitespace`.
+- **Adjacent same-family lists** — consecutive lists of the same family
+  alternate markers (`-`/`*`, `1.`/`1)`) so they stay separate lists on
+  reparse instead of merging (which would renumber ordered items or spread
+  task checkboxes).
+
+## Development
+
+```bash
+python -m pip install .[test]
+python -m pytest
+```
+
+For a direct local CMake build:
+
+```bash
+cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+cmake --build build
+PYTHONPATH=python python -m pytest
+PYTHONPATH=python python scripts/benchmark.py
+```

marktip-0.3.0/README.md

@@ -0,0 +1,118 @@
+# marktip
+
+Fast C++/MD4C Markdown conversion for Tiptap-style JSON.
+
+## Installation
+
+```bash
+python -m pip install marktip
+```
+
+Release wheels are built for common CPython versions on Linux, macOS, and
+Windows. If a wheel is not available for a platform, pip can build from the
+source distribution with a C++17 compiler and standard Python build tooling.
+
+## Usage
+
+```python
+import marktip as tm
+
+doc = tm.from_markdown("# Hello")
+ast = doc.to_dict()
+markdown = doc.to_markdown()
+
+doc = tm.from_dict(ast)
+```
+
+`from_markdown` follows GFM/CommonMark by default. Pass `cjk_friendly=True` to
+relax the emphasis and strikethrough rules so delimiters next to CJK text still
+open and close (e.g. `**볼드**은` parses as bold), a non-standard extension that
+is off by default:
+
+```python
+doc = tm.from_markdown("**볼드**은 강조", cjk_friendly=True)
+```
+
+Strikethrough follows the GFM reference implementations (cmark-gfm/micromark):
+intra-word `~~` strikes (`a~~b~~c`), including next to CJK letters
+(`~~삭제~~은`). `cjk_friendly` still matters for `*`/`_`, and for `~` in
+punctuation-adjacent cases such as `~~"인용"~~라고`.
+
+Pass `html=False` to parse raw HTML as literal text instead of
+`htmlBlock`/`htmlInline` nodes. Content is preserved (the serializer escapes
+it), and `<br>` inside table cells still maps to `hardBreak` so marktip's own
+table output round-trips:
+
+```python
+doc = tm.from_markdown("a <u>x</u> b", html=False)
+# paragraph with the literal text "a <u>x</u> b"
+```
+
+marktip targets GFM core syntax and canonical Markdown output rather than
+byte-identical source preservation.
+
+## Schema enforcement
+
+The Tiptap-side schema is closed: every node/mark type must have a markdown
+mapping. `from_dict` rejects unknown types instead of silently dropping
+content, raising `marktip.UnknownTypeError` — a `ValueError` subclass with
+structured fields for programmatic relay:
+
+```python
+try:
+    tm.from_dict({"type": "doc", "content": [{"type": "callout"}]})
+except tm.UnknownTypeError as e:
+    e.type    # "callout"
+    e.kind    # "node" or "mark"
+    e.path    # "content[0]"
+    e.detail  # "unknown node type 'callout' at content[0]"
+```
+
+Known node types: `doc`, `paragraph`, `text`, `hardBreak`, `heading`,
+`blockquote`, `codeBlock`, `horizontalRule`, `bulletList`, `orderedList`,
+`listItem`, `taskList`, `taskItem`, `table`, `tableRow`, `tableHeader`,
+`tableCell`, `image`, `htmlBlock`, `htmlInline`. Known marks: `bold`,
+`italic`, `strike`, `code`, `link`.
+
+## Defined normalizations
+
+Markdown cannot represent every Tiptap document exactly. Rather than emitting
+markdown that reparses into a different structure, marktip applies these
+deterministic (and idempotent) normalizations at serialization time:
+
+- **Hard breaks in headings** — ATX headings are single-line, so a `hardBreak`
+  (or a literal newline carried over from setext input) inside a heading
+  serializes as a single space: `heading("a", hardBreak, "b")` → `# a b`.
+- **Multi-block table cells** — blocks inside a cell are joined with `<br>`
+  and the cell is flattened to one line; two paragraphs in a cell reparse as
+  one paragraph containing a `hardBreak`.
+- **Headerless tables** — GFM tables require a header row, so the first row is
+  always emitted as the header; a leading `tableCell` row reparses as
+  `tableHeader`.
+- **Heading levels** — clamped to 1–6 at serialization (`0` → `#`, `7` →
+  `######`).
+- **Emphasis boundary whitespace** — whitespace touching an emphasis delimiter
+  has no valid markdown form and is expelled outside the marks
+  (`bold("굵게 ")` → `**굵게** `), cf. prosemirror-markdown's
+  `expelEnclosingWhitespace`.
+- **Adjacent same-family lists** — consecutive lists of the same family
+  alternate markers (`-`/`*`, `1.`/`1)`) so they stay separate lists on
+  reparse instead of merging (which would renumber ordered items or spread
+  task checkboxes).
+
+## Development
+
+```bash
+python -m pip install .[test]
+python -m pytest
+```
+
+For a direct local CMake build:
+
+```bash
+cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+cmake --build build
+PYTHONPATH=python python -m pytest
+PYTHONPATH=python python scripts/benchmark.py
+```

{marktip-0.2.0 → marktip-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "marktip"
-version = "0.2.0"
+version = "0.3.0"
 description = "Fast C++/MD4C Markdown parser and canonical Markdown serializer for Tiptap-style JSON"
 readme = "README.md"
 requires-python = ">=3.9"

{marktip-0.2.0 → marktip-0.3.0}/python/marktip/__init__.py

@@ -1,7 +1,7 @@
 """Fast Markdown conversion for Tiptap-style JSON."""
 
 try:
-    from ._core import Document, __version__, from_dict, from_markdown
+    from ._core import Document, UnknownTypeError, __version__, from_dict, from_markdown
 except ImportError:  # pragma: no cover - development-only CMake build fallback
     import importlib.util
     import pathlib
@@ -21,7 +21,8 @@ except ImportError:  # pragma: no cover - development-only CMake build fallback
 
     __version__ = _module.__version__
     Document = _module.Document
+    UnknownTypeError = _module.UnknownTypeError
     from_dict = _module.from_dict
     from_markdown = _module.from_markdown
 
-__all__ = ["__version__", "Document", "from_markdown", "from_dict"]
+__all__ = ["__version__", "Document", "UnknownTypeError", "from_markdown", "from_dict"]

{marktip-0.2.0 → marktip-0.3.0}/src/ast.cpp

@@ -1,5 +1,7 @@
 #include "ast.h"
 
+#include <algorithm>
+#include <iterator>
 #include <stdexcept>
 
 namespace py = pybind11;
@@ -7,6 +9,50 @@ namespace py = pybind11;
 namespace marktip {
 namespace {
 
+// The closed schema: every node/mark type the parser can emit and the
+// serializer understands. Sorted byte-wise (uppercase sorts before lowercase,
+// e.g. tableCell < tableHeader < tableRow) — required by binary_search; do not
+// "alphabetize" case-insensitively.
+constexpr std::string_view kKnownNodeTypes[] = {
+    "blockquote", "bulletList", "codeBlock",  "doc",         "hardBreak", "heading", "horizontalRule",
+    "htmlBlock",  "htmlInline", "image",      "listItem",    "orderedList", "paragraph", "table",
+    "tableCell",  "tableHeader", "tableRow",  "taskItem",    "taskList",  "text",
+};
+
+constexpr std::string_view kKnownMarkTypes[] = {"bold", "code", "italic", "link", "strike"};
+
+bool is_known_node_type(std::string_view type) {
+    return std::binary_search(std::begin(kKnownNodeTypes), std::end(kKnownNodeTypes), type);
+}
+
+bool is_known_mark_type(std::string_view type) {
+    return std::binary_search(std::begin(kKnownMarkTypes), std::end(kKnownMarkTypes), type);
+}
+
+// Breadcrumb into the input dict, e.g. content[0].content[2].marks[1].
+// Segments are static strings so pushing a frame never allocates; the path
+// string is only rendered when an error is actually thrown.
+struct PathFrame {
+    const char* segment;  // "content" | "marks"
+    std::size_t index;
+};
+
+using PathStack = std::vector<PathFrame>;
+
+std::string format_path(const PathStack& path) {
+    std::string out;
+    for (std::size_t i = 0; i < path.size(); ++i) {
+        if (i != 0) {
+            out.push_back('.');
+        }
+        out += path[i].segment;
+        out.push_back('[');
+        out += std::to_string(path[i].index);
+        out.push_back(']');
+    }
+    return out;
+}
+
 bool dict_contains(py::dict dict, const char* key) {
     return PyMapping_HasKeyString(dict.ptr(), key) == 1;
 }
@@ -124,9 +170,12 @@ py::dict node_to_py(const Document& document, std::size_t index) {
     return out;
 }
 
-Mark mark_from_py(py::dict mark_dict) {
+Mark mark_from_py(py::dict mark_dict, const PathStack& path) {
     Mark mark;
     mark.type = required_type(mark_dict, "mark");
+    if (!is_known_mark_type(mark.type)) {
+        throw UnknownTypeError("mark", mark.type, format_path(path));
+    }
 
     py::object attrs = dict_get(mark_dict, "attrs");
     if (!attrs.is_none()) {
@@ -137,13 +186,16 @@ Mark mark_from_py(py::dict mark_dict) {
 }
 
 void fill_node_from_py(Document& document, std::size_t index, py::dict node_dict, std::string_view context,
-                       std::size_t depth) {
+                       std::size_t depth, PathStack& path) {
     if (depth > kMaxNodeDepth) {
         throw std::invalid_argument("node content nesting exceeds maximum depth");
     }
 
     Node node;
     node.type = required_type(node_dict, context);
+    if (!is_known_node_type(node.type)) {
+        throw UnknownTypeError("node", node.type, format_path(path));
+    }
 
     if (node.type == "text") {
         node.text = py_to_string(dict_get(node_dict, "text"));
@@ -157,8 +209,12 @@ void fill_node_from_py(Document& document, std::size_t index, py::dict node_dict
     py::object marks = dict_get(node_dict, "marks");
     if (!marks.is_none()) {
         py::list mark_list = expect_list(marks, "node marks");
+        std::size_t mark_index = 0;
         for (py::handle mark_handle : mark_list) {
-            node.marks.push_back(mark_from_py(expect_dict(mark_handle, "mark")));
+            path.push_back({"marks", mark_index});
+            node.marks.push_back(mark_from_py(expect_dict(mark_handle, "mark"), path));
+            path.pop_back();
+            ++mark_index;
         }
     }
 
@@ -170,9 +226,13 @@ void fill_node_from_py(Document& document, std::size_t index, py::dict node_dict
     }
 
     py::list content_list = expect_list(content, "node content");
+    std::size_t child_pos = 0;
     for (py::handle child_handle : content_list) {
         std::size_t child_index = document.append_child(index, Node{});
-        fill_node_from_py(document, child_index, expect_dict(child_handle, "content child"), "node", depth + 1);
+        path.push_back({"content", child_pos});
+        fill_node_from_py(document, child_index, expect_dict(child_handle, "content child"), "node", depth + 1, path);
+        path.pop_back();
+        ++child_pos;
     }
 }
 
@@ -336,7 +396,9 @@ Document from_dict_py(py::dict root) {
     }
 
     Document document;
-    fill_node_from_py(document, 0, root, "root node", 0);
+    PathStack path;
+    path.reserve(32);
+    fill_node_from_py(document, 0, root, "root node", 0, path);
     return document;
 }
 

{marktip-0.2.0 → marktip-0.3.0}/src/ast.h

@@ -3,6 +3,7 @@
 #include <pybind11/pybind11.h>
 
 #include <cstddef>
+#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -46,6 +47,27 @@ struct Node {
     std::vector<std::size_t> content;
 };
 
+// Raised by from_dict when a node or mark type is outside the closed schema.
+// Subclasses std::invalid_argument so it surfaces as (a subclass of) ValueError.
+class UnknownTypeError : public std::invalid_argument {
+public:
+    UnknownTypeError(std::string kind, std::string type_name, std::string path)
+        : std::invalid_argument("unknown " + kind + " type '" + type_name + "' at " +
+                                (path.empty() ? std::string("root") : path)),
+          kind_(std::move(kind)),
+          type_name_(std::move(type_name)),
+          path_(std::move(path)) {}
+
+    const std::string& kind() const noexcept { return kind_; }
+    const std::string& type_name() const noexcept { return type_name_; }
+    const std::string& path() const noexcept { return path_; }
+
+private:
+    std::string kind_;       // "node" | "mark"
+    std::string type_name_;
+    std::string path_;       // "content[0].marks[1]"; empty = root
+};
+
 void set_attr(AttrList& attrs, std::string key, AttrValue value);
 const AttrValue* find_attr(const AttrList& attrs, std::string_view key);
 std::string attr_string(const AttrList& attrs, std::string_view key, std::string fallback = {});

marktip-0.3.0/src/marktip.cpp

@@ -0,0 +1,62 @@
+#include <pybind11/gil_safe_call_once.h>
+#include <pybind11/pybind11.h>
+
+#include <exception>
+#include <string>
+
+#include "ast.h"
+#include "parser.h"
+#include "serializer.h"
+
+namespace py = pybind11;
+
+#ifndef MARKTIP_VERSION
+#define MARKTIP_VERSION "0.3.0"
+#endif
+
+PYBIND11_MODULE(_core, module) {
+    module.doc() = "Fast MD4C-backed Markdown conversion with a C++ Document AST";
+    module.attr("__version__") = MARKTIP_VERSION;
+
+    // ValueError subclass carrying structured fields (.type, .path, .kind,
+    // .detail) so callers can relay schema violations programmatically.
+    PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> unknown_type_error_storage;
+    unknown_type_error_storage.call_once_and_store_result([&]() -> py::object {
+        py::object exc = py::exception<marktip::UnknownTypeError>(module, "UnknownTypeError", PyExc_ValueError);
+        exc.attr("__module__") = "marktip._core";
+        return exc;
+    });
+
+    py::register_exception_translator([](std::exception_ptr p) {
+        if (!p) {
+            return;
+        }
+        try {
+            std::rethrow_exception(p);
+        } catch (const marktip::UnknownTypeError& e) {
+            const py::object& exc_type = unknown_type_error_storage.get_stored();
+            py::object exc = exc_type(e.what());
+            exc.attr("type") = e.type_name();
+            exc.attr("path") = e.path();
+            exc.attr("kind") = e.kind();
+            exc.attr("detail") = std::string(e.what());
+            PyErr_SetObject(exc_type.ptr(), exc.ptr());
+        }
+    });
+
+    py::class_<marktip::Document>(module, "Document")
+        .def("to_dict", &marktip::Document::to_dict, "Convert the document AST to a Tiptap-style JSON dict.")
+        .def("to_markdown",
+             [](const marktip::Document& document) {
+                 return marktip::to_markdown(document);
+             },
+             "Serialize the document AST to canonical Markdown.");
+
+    module.def("from_markdown", &marktip::from_markdown_py, py::arg("markdown"), py::arg("cjk_friendly") = false,
+               py::arg("html") = true,
+               "Parse Markdown into a Document. Set cjk_friendly=True to relax the emphasis rules around CJK text "
+               "(non-standard extension; the default follows GFM/CommonMark exactly). Set html=False to parse raw "
+               "HTML as literal text instead of htmlBlock/htmlInline nodes; <br> inside table cells still maps to "
+               "hardBreak.");
+    module.def("from_dict", &marktip::from_dict_py, py::arg("ast"), "Build a Document from a Tiptap-style JSON dict.");
+}

{marktip-0.2.0 → marktip-0.3.0}/src/parser.cpp

@@ -147,8 +147,8 @@ std::string align_to_string(MD_ALIGN align) {
 
 class AstBuilder {
 public:
-    explicit AstBuilder(std::size_t input_size = 0)
-        : document_(std::max<std::size_t>(32, input_size / 24)) {
+    explicit AstBuilder(std::size_t input_size = 0, bool html = true)
+        : document_(std::max<std::size_t>(32, input_size / 24)), html_(html) {
         stack_.push_back(0);
     }
 
@@ -412,6 +412,7 @@ private:
     std::vector<std::size_t> stack_;
     std::vector<Mark> active_marks_;
     std::string error_;
+    bool html_ = true;
 
     Node& current() {
         return document_.node(stack_.back());
@@ -517,12 +518,19 @@ private:
         }
 
         // Table cells cannot hold literal newlines, so hard breaks in cells are
-        // serialized as <br>; map them back to hardBreak when parsing.
+        // serialized as <br>; map them back to hardBreak when parsing. This
+        // must stay ahead of the html_ gate so marktip's own cell output
+        // round-trips even with html disabled.
         if (is_br_tag(value) && (current().type == "tableCell" || current().type == "tableHeader")) {
             add_hard_break();
             return;
         }
 
+        if (!html_) {
+            add_text(value);
+            return;
+        }
+
         std::size_t parent_index = stack_.back();
         Node& parent = document_.node(parent_index);
         if (!parent.content.empty()) {
@@ -704,11 +712,16 @@ int text_callback(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* use
     }
 }
 
-Document parse_to_document(const std::string& markdown, bool cjk_friendly) {
-    AstBuilder builder(markdown.size());
+Document parse_to_document(const std::string& markdown, bool cjk_friendly, bool html) {
+    AstBuilder builder(markdown.size(), html);
     MD_PARSER parser {};
     parser.abi_version = 0;
-    parser.flags = MD_DIALECT_GITHUB | (cjk_friendly ? MD_FLAG_CJKFRIENDLYEMPHASIS : 0);
+    // With html=false, block-level raw HTML degrades to paragraph text via
+    // MD_FLAG_NOHTMLBLOCKS. Inline HTML spans stay recognized (no
+    // MD_FLAG_NOHTMLSPANS) so the <br>-in-cell hardBreak mapping keeps
+    // working; AstBuilder turns the remaining spans into literal text.
+    parser.flags = MD_DIALECT_GITHUB | (cjk_friendly ? MD_FLAG_CJKFRIENDLYEMPHASIS : 0) |
+                   (html ? 0 : MD_FLAG_NOHTMLBLOCKS);
     parser.enter_block = enter_block_callback;
     parser.leave_block = leave_block_callback;
     parser.enter_span = enter_span_callback;
@@ -729,7 +742,7 @@ Document parse_to_document(const std::string& markdown, bool cjk_friendly) {
 
 }  // namespace
 
-Document from_markdown_py(py::object markdown, bool cjk_friendly) {
+Document from_markdown_py(py::object markdown, bool cjk_friendly, bool html) {
     std::string input;
     if (py::isinstance<py::str>(markdown) || py::isinstance<py::bytes>(markdown)) {
         input = py::cast<std::string>(markdown);
@@ -740,7 +753,7 @@ Document from_markdown_py(py::object markdown, bool cjk_friendly) {
     Document document;
     {
         py::gil_scoped_release release;
-        document = parse_to_document(input, cjk_friendly);
+        document = parse_to_document(input, cjk_friendly, html);
     }
     return document;
 }

{marktip-0.2.0 → marktip-0.3.0}/src/parser.h

@@ -6,6 +6,6 @@
 
 namespace marktip {
 
-Document from_markdown_py(pybind11::object markdown, bool cjk_friendly);
+Document from_markdown_py(pybind11::object markdown, bool cjk_friendly, bool html);
 
 }  // namespace marktip