markdown-to-confluence 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

md2conf/csf.py

@@ -0,0 +1,151 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import importlib.resources as resources
+import re
+from pathlib import Path
+from typing import Callable, TypeVar
+
+import lxml.etree as ET
+from lxml.builder import ElementMaker
+
+# XML namespaces typically associated with Confluence Storage Format documents
+_namespaces = {
+    "ac": "http://atlassian.com/content",
+    "ri": "http://atlassian.com/resource/identifier",
+}
+for key, value in _namespaces.items():
+    ET.register_namespace(key, value)
+
+HTML = ElementMaker()
+AC_ELEM = ElementMaker(namespace=_namespaces["ac"])
+RI_ELEM = ElementMaker(namespace=_namespaces["ri"])
+
+
+class ParseError(RuntimeError):
+    pass
+
+
+def _qname(namespace_uri: str, name: str) -> str:
+    return ET.QName(namespace_uri, name).text
+
+
+def AC_ATTR(name: str) -> str:
+    return _qname(_namespaces["ac"], name)
+
+
+def RI_ATTR(name: str) -> str:
+    return _qname(_namespaces["ri"], name)
+
+
+R = TypeVar("R")
+
+
+def with_entities(func: Callable[[Path], R]) -> R:
+    "Invokes a callable in the context of an entity definition file."
+
+    resource_path = resources.files(__package__).joinpath("entities.dtd")
+    with resources.as_file(resource_path) as dtd_path:
+        return func(dtd_path)
+
+
+def _elements_from_strings(dtd_path: Path, items: list[str]) -> ET._Element:
+    """
+    Creates an XML document tree from XML fragment strings.
+
+    This function
+    * adds an XML declaration,
+    * wraps the content in a root element,
+    * adds namespace declarations associated with Confluence documents.
+
+    :param dtd_path: Path to a DTD document that defines entities like `¢` or `©`.
+    :param items: Strings to parse into XML fragments.
+    :returns: An XML document as an element tree.
+    """
+
+    parser = ET.XMLParser(
+        remove_blank_text=True,
+        remove_comments=True,
+        strip_cdata=False,
+        load_dtd=True,
+    )
+
+    ns_attr_list = "".join(f' xmlns:{key}="{value}"' for key, value in _namespaces.items())
+
+    data = [
+        '<?xml version="1.0"?>',
+        f'<!DOCTYPE ac:confluence PUBLIC "-//Atlassian//Confluence 4 Page//EN" "{dtd_path.as_posix()}"><root{ns_attr_list}>',
+    ]
+    data.extend(items)
+    data.append("</root>")
+
+    try:
+        return ET.fromstringlist(data, parser=parser)
+    except ET.XMLSyntaxError as ex:
+        raise ParseError() from ex
+
+
+def elements_from_strings(items: list[str]) -> ET._Element:
+    """
+    Creates a Confluence Storage Format XML document tree from XML fragment strings.
+
+    A root element is created to hold several XML fragments.
+
+    :param items: Strings to parse into XML fragments.
+    :returns: An XML document as an element tree.
+    """
+
+    return with_entities(lambda dtd_path: _elements_from_strings(dtd_path, items))
+
+
+def elements_from_string(content: str) -> ET._Element:
+    """
+    Creates a Confluence Storage Format XML document tree from an XML string.
+
+    :param content: String to parse into XML.
+    :returns: An XML document as an element tree.
+    """
+
+    return elements_from_strings([content])
+
+
+def _content_to_string(dtd_path: Path, content: str) -> str:
+    tree = _elements_from_strings(dtd_path, [content])
+    return ET.tostring(tree, pretty_print=True).decode("utf-8")
+
+
+def content_to_string(content: str) -> str:
+    """
+    Converts a Confluence Storage Format document returned by the Confluence REST API into a readable XML document.
+
+    This function
+    * adds an XML declaration,
+    * wraps the content in a root element,
+    * adds namespace declarations associated with Confluence documents.
+
+    :param content: Confluence Storage Format content as a string.
+    :returns: XML as a string.
+    """
+
+    return with_entities(lambda dtd_path: _content_to_string(dtd_path, content))
+
+
+def elements_to_string(root: ET._Element) -> str:
+    """
+    Converts a Confluence Storage Format element tree into an XML string to push to Confluence REST API.
+
+    :param root: Synthesized XML element tree of a Confluence Storage Format document.
+    :returns: XML as a string.
+    """
+
+    xml = ET.tostring(root, encoding="utf8", method="xml").decode("utf8")
+    m = re.match(r"^<root\s+[^>]*>(.*)</root>\s*$", xml, re.DOTALL)
+    if m:
+        return m.group(1)
+    else:
+        raise ValueError("expected: Confluence content")

md2conf/domain.py

@@ -0,0 +1,46 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+
+@dataclass
+class ConfluencePageID:
+    page_id: str
+
+
+@dataclass
+class ConfluenceDocumentOptions:
+    """
+    Options that control the generated page content.
+
+    :param ignore_invalid_url: When true, ignore invalid URLs in input, emit a warning and replace the anchor with
+        plain text; when false, raise an exception.
+    :param heading_anchors: When true, emit a structured macro *anchor* for each section heading using GitHub
+        conversion rules for the identifier.
+    :param generated_by: Text to use as the generated-by prompt (or `None` to omit a prompt).
+    :param root_page_id: Confluence page to assume root page role for publishing a directory of Markdown files.
+    :param keep_hierarchy: Whether to maintain source directory structure when exporting to Confluence.
+    :param prefer_raster: Whether to choose PNG files over SVG files when available.
+    :param render_drawio: Whether to pre-render (or use the pre-rendered version of) draw.io diagrams.
+    :param render_mermaid: Whether to pre-render Mermaid diagrams into PNG/SVG images.
+    :param diagram_output_format: Target image format for diagrams.
+    :param webui_links: When true, convert relative URLs to Confluence Web UI links.
+    """
+
+    ignore_invalid_url: bool = False
+    heading_anchors: bool = False
+    generated_by: Optional[str] = "This page has been generated with a tool."
+    root_page_id: Optional[ConfluencePageID] = None
+    keep_hierarchy: bool = False
+    prefer_raster: bool = True
+    render_drawio: bool = False
+    render_mermaid: bool = False
+    diagram_output_format: Literal["png", "svg"] = "png"
+    webui_links: bool = False

md2conf/drawio.py

@@ -7,6 +7,11 @@ Copyright 2022-2025, Levente Hunyadi
 """
 
 import base64
+import logging
+import os
+import os.path
+import shutil
+import subprocess
 import typing
 import zlib
 from pathlib import Path
@@ -15,6 +20,8 @@ from urllib.parse import unquote_to_bytes
 
 import lxml.etree as ET
 
+LOGGER = logging.getLogger(__name__)
+
 
 class DrawioError(ValueError):
     """
@@ -220,3 +227,45 @@ def extract_diagram(path: Path) -> bytes:
         raise DrawioError(f"unrecognized file type for {path.name}")
 
     return ET.tostring(root, encoding="utf8", method="xml")
+
+
+def render_diagram(source: Path, output_format: typing.Literal["png", "svg"] = "png") -> bytes:
+    "Generates a PNG or SVG image from a draw.io diagram source."
+
+    executable = shutil.which("draw.io")
+    if executable is None:
+        raise DrawioError("draw.io executable not found")
+
+    target = f"tmp_drawio.{output_format}"
+
+    cmd = [executable, "--export", "--format", output_format, "--output", target]
+    if output_format == "png":
+        cmd.extend(["--scale", "2", "--transparent"])
+    elif output_format == "svg":
+        cmd.append("--embed-svg-images")
+    cmd.append(str(source))
+
+    LOGGER.debug("Executing: %s", " ".join(cmd))
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+        )
+        stdout, stderr = proc.communicate()
+        if proc.returncode:
+            messages = [f"failed to convert draw.io diagram; exit code: {proc.returncode}"]
+            console_output = stdout.decode("utf-8")
+            if console_output:
+                messages.append(f"output:\n{console_output}")
+            console_error = stderr.decode("utf-8")
+            if console_error:
+                messages.append(f"error:\n{console_error}")
+            raise DrawioError("\n".join(messages))
+        with open(target, "rb") as f:
+            return f.read()
+
+    finally:
+        if os.path.exists(target):
+            os.remove(target)

md2conf/local.py

@@ -11,7 +11,8 @@ import os
 from pathlib import Path
 from typing import Optional
 
-from .converter import ConfluenceDocument, ConfluenceDocumentOptions, ConfluencePageID
+from .converter import ConfluenceDocument
+from .domain import ConfluenceDocumentOptions, ConfluencePageID
 from .extra import override
 from .metadata import ConfluencePageMetadata, ConfluenceSiteMetadata
 from .processor import Converter, DocumentNode, Processor, ProcessorFactory
@@ -77,10 +78,14 @@ class LocalProcessor(Processor):
         """
 
         content = document.xhtml()
-        out_path = self.out_dir / path.relative_to(self.root_dir).with_suffix(".csf")
-        os.makedirs(out_path.parent, exist_ok=True)
-        with open(out_path, "w", encoding="utf-8") as f:
+        csf_path = self.out_dir / path.relative_to(self.root_dir).with_suffix(".csf")
+        csf_dir = csf_path.parent
+        os.makedirs(csf_dir, exist_ok=True)
+        with open(csf_path, "w", encoding="utf-8") as f:
             f.write(content)
+        for name, data in document.embedded_files.items():
+            with open(csf_dir / name, "wb") as f:
+                f.write(data)
 
 
 class LocalProcessorFactory(ProcessorFactory):

md2conf/markdown.py

@@ -0,0 +1,114 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import xml.etree.ElementTree
+from typing import Any, Optional
+
+import markdown
+
+
+def _emoji_generator(
+    index: str,
+    shortname: str,
+    alias: Optional[str],
+    uc: Optional[str],
+    alt: str,
+    title: Optional[str],
+    category: Optional[str],
+    options: dict[str, Any],
+    md: markdown.Markdown,
+) -> xml.etree.ElementTree.Element:
+    """
+    Custom generator for `pymdownx.emoji`.
+    """
+
+    name = (alias or shortname).strip(":")
+    emoji = xml.etree.ElementTree.Element("x-emoji", {"data-shortname": name})
+    if uc is not None:
+        emoji.attrib["data-unicode"] = uc
+
+        # convert series of Unicode code point hexadecimal values into characters
+        emoji.text = "".join(chr(int(item, base=16)) for item in uc.split("-"))
+    else:
+        emoji.text = alt
+
+    return emoji
+
+
+def _verbatim_formatter(
+    source: str,
+    language: str,
+    css_class: str,
+    options: dict[str, Any],
+    md: markdown.Markdown,
+    classes: Optional[list[str]] = None,
+    id_value: str = "",
+    attrs: Optional[dict[str, str]] = None,
+    **kwargs: Any,
+) -> str:
+    """
+    Custom formatter for `pymdownx.superfences`.
+
+    Used by language `math` (a.k.a. `pymdownx.arithmatex`) and pseudo-language `csf` (Confluence Storage Format pass-through).
+    """
+
+    if classes is None:
+        classes = [css_class]
+    else:
+        classes.insert(0, css_class)
+
+    html_id = f' id="{id_value}"' if id_value else ""
+    html_class = ' class="{}"'.format(" ".join(classes))
+    html_attrs = " " + " ".join(f'{k}="{v}"' for k, v in attrs.items()) if attrs else ""
+
+    return f"<div{html_id}{html_class}{html_attrs}>{source}</div>"
+
+
+_CONVERTER = markdown.Markdown(
+    extensions=[
+        "admonition",
+        "footnotes",
+        "markdown.extensions.tables",
+        "md_in_html",
+        "pymdownx.arithmatex",
+        "pymdownx.emoji",
+        "pymdownx.highlight",  # required by `pymdownx.superfences`
+        "pymdownx.magiclink",
+        "pymdownx.superfences",
+        "pymdownx.tilde",
+        "sane_lists",
+    ],
+    extension_configs={
+        "footnotes": {"BACKLINK_TITLE": ""},
+        "pymdownx.arithmatex": {"generic": True, "preview": False, "tex_inline_wrap": ["", ""], "tex_block_wrap": ["", ""]},
+        "pymdownx.emoji": {"emoji_generator": _emoji_generator, "strict": True},
+        "pymdownx.highlight": {
+            "use_pygments": False,
+        },
+        "pymdownx.superfences": {
+            "custom_fences": [
+                {"name": "math", "class": "arithmatex", "format": _verbatim_formatter},
+                {"name": "csf", "class": "csf", "format": _verbatim_formatter},
+            ]
+        },
+    },
+)
+
+
+def markdown_to_html(content: str) -> str:
+    """
+    Converts a Markdown document into XHTML with Python-Markdown.
+
+    :param content: Markdown input as a string.
+    :returns: XHTML output as a string.
+    :see: https://python-markdown.github.io/
+    """
+
+    _CONVERTER.reset()
+    html = _CONVERTER.convert(content)
+    return html

md2conf/processor.py

@@ -14,7 +14,8 @@ from pathlib import Path
 from typing import Iterable, Optional
 
 from .collection import ConfluencePageCollection
-from .converter import ConfluenceDocument, ConfluenceDocumentOptions, ConfluencePageID
+from .converter import ConfluenceDocument
+from .domain import ConfluenceDocumentOptions, ConfluencePageID
 from .matcher import DirectoryEntry, FileEntry, Matcher, MatcherOptions
 from .metadata import ConfluenceSiteMetadata
 from .properties import ArgumentError

md2conf/toc.py

@@ -0,0 +1,89 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(eq=True)
+class TableOfContentsEntry:
+    """
+    Represents a table of contents entry.
+
+    :param level: The heading level assigned to the entry. Each entry can only contain children whose level is strictly greater than of its parent.
+    :param text: The heading text.
+    :param children: Direct descendants whose parent is this entry.
+    """
+
+    level: int
+    text: str
+    children: list["TableOfContentsEntry"]
+
+    def __init__(self, level: int, text: str, children: Optional[list["TableOfContentsEntry"]] = None) -> None:
+        self.level = level
+        self.text = text
+        self.children = children or []
+
+
+class TableOfContentsBuilder:
+    """
+    Builds a table of contents from Markdown headings.
+    """
+
+    _root: TableOfContentsEntry
+    _stack: list[TableOfContentsEntry]
+
+    def __init__(self) -> None:
+        self._root = TableOfContentsEntry(0, "<root>")
+        self._stack = [self._root]
+
+    @property
+    def tree(self) -> list[TableOfContentsEntry]:
+        """
+        Table of contents as a hierarchy of headings.
+        """
+
+        return self._root.children
+
+    def add(self, level: int, text: str) -> None:
+        """
+        Adds a heading to the table of contents.
+
+        :param level: Markdown heading level (e.g. `1` for first-level heading).
+        :param text: Markdown heading text.
+        """
+
+        if level < 1:
+            raise ValueError("expected: Markdown heading level >= 1")
+
+        # remove any stack items deeper than the current level
+        top = self._stack[-1]
+        while top.level >= level:
+            self._stack.pop()
+            top = self._stack[-1]
+
+        # add the new section under the current top level
+        item = TableOfContentsEntry(level, text)
+        top.children.append(item)
+
+        # push new level onto the stack
+        self._stack.append(item)
+
+    def get_title(self) -> Optional[str]:
+        """
+        Returns a proposed document title.
+
+        The proposed title is text of the top-level heading if and only if that heading is unique.
+
+        :returns: Title text, or `None` if no title can be inferred.
+        """
+
+        if len(self.tree) == 1:
+            return self.tree[0].text
+        else:
+            return None

md2conf/uri.py

@@ -0,0 +1,46 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import hashlib
+import urllib.parse
+import uuid
+from urllib.parse import urlparse
+
+
+def to_data_uri(mime: str, data: str) -> str:
+    "Generates a data URI with the specified MIME type."
+
+    # URL-encode data
+    encoded = urllib.parse.quote(data, safe=";/?:@&=+$,-_.!~*'()#")  # minimal encoding
+    return f"data:{mime},{encoded}"
+
+
+def to_uuid(data: str) -> uuid.UUID:
+    "Generates a UUID that represents the data."
+
+    # create SHA-1 hash of the SVG content
+    sha1_hash = hashlib.sha1(data.encode("utf-8")).digest()
+
+    # generate UUID using the first 16 bytes of the hash
+    return uuid.UUID(bytes=sha1_hash[:16])
+
+
+def to_uuid_urn(data: str) -> str:
+    "Generates a UUID URN that represents the data."
+
+    return f"urn:uuid:{str(to_uuid(data))}"
+
+
+def is_absolute_url(url: str) -> bool:
+    urlparts = urlparse(url)
+    return bool(urlparts.scheme) or bool(urlparts.netloc)
+
+
+def is_relative_url(url: str) -> bool:
+    urlparts = urlparse(url)
+    return not bool(urlparts.scheme) and not bool(urlparts.netloc)

md2conf/xml.py

@@ -1,11 +1,21 @@
-from typing import Iterable, Optional, Union
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+from typing import Iterable, Optional
 
 import lxml.etree as ET
 
 
-def _attrs_equal_excluding(attrs1: ET._Attrib, attrs2: ET._Attrib, exclude: set[Union[str, ET.QName]]) -> bool:
+def _attrs_equal_excluding(attrs1: ET._Attrib, attrs2: ET._Attrib, exclude: set[str]) -> bool:
     """
     Compares two dictionary objects, excluding keys in the skip set.
+
+    :param exclude: Attributes to exclude, in `{namespace}name` notation.
     """
 
     # create key sets to compare, excluding keys to be skipped
@@ -23,10 +33,19 @@ def _attrs_equal_excluding(attrs1: ET._Attrib, attrs2: ET._Attrib, exclude: set[
 
 
 class ElementComparator:
-    skip_attributes: set[Union[str, ET.QName]]
+    skip_attributes: set[str]
+    skip_elements: set[str]
+
+    def __init__(self, *, skip_attributes: Optional[Iterable[str]] = None, skip_elements: Optional[Iterable[str]] = None):
+        """
+        Initializes a new element tree comparator.
+
+        :param skip_attributes: Attributes to exclude, in `{namespace}name` notation.
+        :param skip_elements: Elements to exclude, in `{namespace}name` notation.
+        """
 
-    def __init__(self, *, skip_attributes: Optional[Iterable[Union[str, ET.QName]]] = None):
         self.skip_attributes = set(skip_attributes) if skip_attributes else set()
+        self.skip_elements = set(skip_elements) if skip_elements else set()
 
     def is_equal(self, e1: ET._Element, e2: ET._Element) -> bool:
         """
@@ -36,35 +55,49 @@ class ElementComparator:
         if e1.tag != e2.tag:
             return False
 
-        e1_text = e1.text.strip() if e1.text else ""
-        e2_text = e2.text.strip() if e2.text else ""
-        if e1_text != e2_text:
-            return False
-
+        # compare tail first, which is outside of element
         e1_tail = e1.tail.strip() if e1.tail else ""
         e2_tail = e2.tail.strip() if e2.tail else ""
         if e1_tail != e2_tail:
             return False
 
+        # skip element (and content) if on ignore list
+        if e1.tag in self.skip_elements:
+            return True
+
+        # compare text second, which is encapsulated by element
+        e1_text = e1.text.strip() if e1.text else ""
+        e2_text = e2.text.strip() if e2.text else ""
+        if e1_text != e2_text:
+            return False
+
+        # compare attributes, disregarding definition order
         if not _attrs_equal_excluding(e1.attrib, e2.attrib, self.skip_attributes):
             return False
+
+        # compare children recursively
         if len(e1) != len(e2):
             return False
         return all(self.is_equal(c1, c2) for c1, c2 in zip(e1, e2))
 
 
 def is_xml_equal(
-    tree1: ET._Element,
-    tree2: ET._Element,
-    *,
-    skip_attributes: Optional[Iterable[Union[str, ET.QName]]] = None,
+    tree1: ET._Element, tree2: ET._Element, *, skip_attributes: Optional[Iterable[str]] = None, skip_elements: Optional[Iterable[str]] = None
 ) -> bool:
     """
     Compare two XML documents for equivalence, ignoring leading/trailing whitespace differences and attribute definition order.
 
     :param tree1: XML document as an element tree.
     :param tree2: XML document as an element tree.
+    :param skip_attributes: Attributes to exclude, in `{namespace}name` notation.
+    :param skip_elements: Elements to exclude, in `{namespace}name` notation.
     :returns: True if equivalent, False otherwise.
     """
 
-    return ElementComparator(skip_attributes=skip_attributes).is_equal(tree1, tree2)
+    return ElementComparator(skip_attributes=skip_attributes, skip_elements=skip_elements).is_equal(tree1, tree2)
+
+
+def element_to_text(node: ET._Element) -> str:
+    "Returns all text contained in an element as a concatenated string."
+
+    return "".join(node.itertext()).strip()

markdown_to_confluence-0.4.2.dist-info/RECORD

@@ -1,27 +0,0 @@
-markdown_to_confluence-0.4.2.dist-info/licenses/LICENSE,sha256=Pv43so2bPfmKhmsrmXFyAvS7M30-1i1tzjz6-dfhyOo,1077
-md2conf/__init__.py,sha256=XAJAgUDrYS3PdOzoo2BQ-rM3PbQWOrOW2kPt5iJ8xY0,402
-md2conf/__main__.py,sha256=qyboDihyVTm0EZa_c3AFWF1AojhL8-bww_kISAa5nHQ,10130
-md2conf/api.py,sha256=DbG1udDb9ti4OjqgSW3DSuHwxKNFPVDTkhjnaB1GNMI,37193
-md2conf/application.py,sha256=X_V4KdFACHwl5Nt4BIHQyhtecOqNOzknrPyPTW0d4Z0,8185
-md2conf/collection.py,sha256=EobgMRJgkYloWlY03NZJ52MRC_SGLpTVCHkltDbQyt0,837
-md2conf/converter.py,sha256=Eg6emS77GQAkhbXutaRjHxcBFgmXp_4z_zOAmBfqxUY,54360
-md2conf/drawio.py,sha256=G_pD2nafl7dXuFK_4MBiEUl0ZZGNuagnHw6GFOrev94,6717
-md2conf/emoji.py,sha256=UzDrxqFo59wHmbbJmMNdn0rYFDXbZE4qirOM-_egzXc,2603
-md2conf/entities.dtd,sha256=M6NzqL5N7dPs_eUA_6sDsiSLzDaAacrx9LdttiufvYU,30215
-md2conf/extra.py,sha256=VuMxuOnnC2Qwy6y52ukIxsaYhrZArRqMmRHRE4QZl8g,687
-md2conf/local.py,sha256=Ph-cGc_JQ1SkvuZ_Jxn37dlpaKZYKLVPBnsk5CGSVnk,3548
-md2conf/matcher.py,sha256=m5rZjYZSjhKfdeKS8JdPq7cG861Mc6rVZBkrIOZTHGE,6916
-md2conf/mermaid.py,sha256=f0x7ISj-41ZMh4zTAFPhIWwr94SDcsVZUc1NWqmH_G4,2508
-md2conf/metadata.py,sha256=LzZM-oPNnzCULmLhF516tPlV5zZBknccwMHt8Nan-xg,1007
-md2conf/processor.py,sha256=59XDWKgTvJwEZ1y52VfRkM67K2-Ivh7kGD6Eg2tfG9c,9713
-md2conf/properties.py,sha256=RC1jY_TKVbOv2bJxXn27Fj4fNWzyoNUQt6ltgUyVQAQ,3987
-md2conf/puppeteer-config.json,sha256=-dMTAN_7kNTGbDlfXzApl0KJpAWna9YKZdwMKbpOb60,159
-md2conf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-md2conf/scanner.py,sha256=Cyvjab8tBvKgubttQvNagS8nailuTvFBqUGoiX5MNp8,5351
-md2conf/xml.py,sha256=HoKJfF1yRZ3Gk8jTS-kRpOqVs0nQJZyr56l0Fo3y9fs,2193
-markdown_to_confluence-0.4.2.dist-info/METADATA,sha256=ggIrg30RRTvk3ax2LKC_wKjMhOEhrXOYVrSwvb2dDbw,29495
-markdown_to_confluence-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_to_confluence-0.4.2.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
-markdown_to_confluence-0.4.2.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
-markdown_to_confluence-0.4.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-markdown_to_confluence-0.4.2.dist-info/RECORD,,