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

md2conf/csf.py

@@ -149,3 +149,69 @@ def elements_to_string(root: ET._Element) -> str:
         return m.group(1)
     else:
         raise ValueError("expected: Confluence content")
+
+
+def is_block_like(elem: ET._Element) -> bool:
+    return elem.tag in ["div", "li", "ol", "p", "pre", "ul"]
+
+
+def normalize_inline(elem: ET._Element) -> None:
+    """
+    Ensures that inline elements are direct children of an eligible block element.
+
+    The following transformations are applied:
+
+    * consecutive inline elements and text nodes that are the direct children of the parent element are wrapped into a `<p>`,
+    * block elements are left intact,
+    * leading and trailing whitespace in each block element is removed.
+
+    The above steps transform an element tree such as
+    ```
+    <li>  to <em>be</em>, <ol/> not to <em>be</em>  </li>
+    ```
+
+    into another element tree such as
+    ```
+    <li><p>to <em>be</em>,</p><ol/><p>not to <em>be</em></p></li>
+    ```
+    """
+
+    if not is_block_like(elem):
+        raise ValueError(f"expected: block element; got: {elem.tag!s}")
+
+    contents: list[ET._Element] = []
+
+    paragraph = HTML.p()
+    contents.append(paragraph)
+    if elem.text:
+        paragraph.text = elem.text
+        elem.text = None
+
+    for child in elem:
+        if is_block_like(child):
+            contents.append(child)
+            paragraph = HTML.p()
+            contents.append(paragraph)
+            if child.tail:
+                paragraph.text = child.tail
+                child.tail = None
+        else:
+            paragraph.append(child)
+
+    for item in contents:
+        # remove lead whitespace in the block element
+        if item.text:
+            item.text = item.text.lstrip()
+        if len(item) > 0:
+            # remove tail whitespace in the last child of the block element
+            last = item[-1]
+            if last.tail:
+                last.tail = last.tail.rstrip()
+        else:
+            # remove tail whitespace directly in the block element content
+            if item.text:
+                item.text = item.text.rstrip()
+
+        # ignore empty elements
+        if item.tag != "p" or len(item) > 0 or item.text:
+            elem.append(item)

md2conf/domain.py

@@ -30,6 +30,7 @@ class ConfluenceDocumentOptions:
     :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 render_latex: Whether to pre-render LaTeX formulas 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.
     """
@@ -42,5 +43,6 @@ class ConfluenceDocumentOptions:
     prefer_raster: bool = True
     render_drawio: bool = False
     render_mermaid: bool = False
+    render_latex: bool = False
     diagram_output_format: Literal["png", "svg"] = "png"
     webui_links: bool = False

md2conf/drawio.py

@@ -9,9 +9,9 @@ Copyright 2022-2025, Levente Hunyadi
 import base64
 import logging
 import os
-import os.path
 import shutil
 import subprocess
+import tempfile
 import typing
 import zlib
 from pathlib import Path
@@ -153,7 +153,8 @@ def extract_xml_from_png(png_data: bytes) -> ET._Element:
         offset += 8
 
         if offset + length + 4 > len(png_data):
-            raise DrawioError(f"corrupted PNG: incomplete data for chunk {chunk_type.decode('ascii')}")
+            chunk_name = chunk_type.decode("ascii", errors="replace")
+            raise DrawioError(f"corrupted PNG: incomplete data for chunk {chunk_name}")
 
         # read chunk data
         chunk_data = png_data[offset : offset + length]
@@ -169,7 +170,7 @@ def extract_xml_from_png(png_data: bytes) -> ET._Element:
         # format: keyword\0text
         null_pos = chunk_data.find(b"\x00")
         if null_pos < 0:
-            raise DrawioError("corrupted PNG: tEXt chunk missing keyword")
+            raise DrawioError("corrupted PNG: `tEXt` chunk missing keyword or data")
 
         keyword = chunk_data[:null_pos].decode("latin1")
         if keyword != "mxfile":
@@ -236,17 +237,21 @@ def render_diagram(source: Path, output_format: typing.Literal["png", "svg"] = "
     if executable is None:
         raise DrawioError("draw.io executable not found")
 
-    target = f"tmp_drawio.{output_format}"
+    # create a temporary file and get its file descriptor and path
+    fd, target = tempfile.mkstemp(prefix="drawio_", suffix=f".{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:
+        # close the descriptor, just use the filename
+        os.close(fd)
+
+        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))
         proc = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE,
@@ -267,5 +272,4 @@ def render_diagram(source: Path, output_format: typing.Literal["png", "svg"] = "
             return f.read()
 
     finally:
-        if os.path.exists(target):
-            os.remove(target)
+        os.remove(target)

md2conf/latex.py

@@ -0,0 +1,245 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import importlib.util
+from io import BytesIO
+from pathlib import Path
+from struct import unpack
+from typing import BinaryIO, Iterable, Literal, Optional, Union, overload
+
+
+def render_latex(expression: str, *, format: Literal["png", "svg"] = "png", dpi: int = 100, font_size: int = 12) -> bytes:
+    """
+    Generates a PNG or SVG image of a LaTeX math expression using `matplotlib` for rendering.
+
+    :param expression: A LaTeX math expression, e.g., r'\frac{a}{b}'.
+    :param format: Output image format.
+    :param dpi: Output image resolution (if applicable).
+    :param font_size: Font size of the LaTeX text (if applicable).
+    """
+
+    with BytesIO() as f:
+        _render_latex(expression, f, format=format, dpi=dpi, font_size=font_size)
+        return f.getvalue()
+
+
+if importlib.util.find_spec("matplotlib") is None:
+    LATEX_ENABLED = False
+
+    def _render_latex(expression: str, f: BinaryIO, *, format: Literal["png", "svg"], dpi: int, font_size: int) -> None:
+        raise RuntimeError("matplotlib not installed; run: `pip install matplotlib`")
+
+else:
+    import matplotlib
+    import matplotlib.pyplot as plt
+
+    matplotlib.rcParams["mathtext.fontset"] = "cm"  # change font to "Computer Modern"
+
+    LATEX_ENABLED = True
+
+    def _render_latex(expression: str, f: BinaryIO, *, format: Literal["png", "svg"], dpi: int, font_size: int) -> None:
+        # create a figure with no axis
+        fig = plt.figure(dpi=dpi)
+
+        # transparent background
+        fig.patch.set_alpha(0)
+
+        # add LaTeX text
+        fig.text(x=0, y=0, s=f"${expression}$", fontsize=font_size)
+
+        # save the image
+        fig.savefig(
+            f,
+            transparent=True,
+            format=format,
+            bbox_inches="tight",
+            pad_inches=0.0,
+            metadata={"Title": expression} if format == "png" else None,
+        )
+
+        # close the figure to free memory
+        plt.close(fig)
+
+
+@overload
+def get_png_dimensions(*, data: bytes) -> tuple[int, int]: ...
+
+
+@overload
+def get_png_dimensions(*, path: Union[str, Path]) -> tuple[int, int]: ...
+
+
+def get_png_dimensions(*, data: Optional[bytes] = None, path: Union[str, Path, None] = None) -> tuple[int, int]:
+    """
+    Returns the width and height of a PNG image inspecting its header.
+
+    :param data: PNG image data.
+    :param path: Path to the PNG image file.
+    :returns: A tuple of the image's width and height in pixels.
+    """
+
+    if data is not None and path is not None:
+        raise TypeError("expected: either `data` or `path`; got: both")
+    elif data is not None:
+        with BytesIO(data) as f:
+            return _get_png_dimensions(f)
+    elif path is not None:
+        with open(path, "rb") as f:
+            return _get_png_dimensions(f)
+    else:
+        raise TypeError("expected: either `data` or `path`; got: neither")
+
+
+@overload
+def remove_png_chunks(names: Iterable[str], *, source_data: bytes) -> bytes: ...
+
+
+@overload
+def remove_png_chunks(names: Iterable[str], *, source_path: Union[str, Path]) -> bytes: ...
+
+
+@overload
+def remove_png_chunks(names: Iterable[str], *, source_data: bytes, target_path: Union[str, Path]) -> None: ...
+
+
+@overload
+def remove_png_chunks(names: Iterable[str], *, source_path: Union[str, Path], target_path: Union[str, Path]) -> None: ...
+
+
+def remove_png_chunks(
+    names: Iterable[str], *, source_data: Optional[bytes] = None, source_path: Union[str, Path, None] = None, target_path: Union[str, Path, None] = None
+) -> Optional[bytes]:
+    """
+    Rewrites a PNG file by removing chunks with the specified names.
+
+    :param source_data: PNG image data.
+    :param source_path: Path to the file to read from.
+    :param target_path: Path to the file to write to.
+    """
+
+    if source_data is not None and source_path is not None:
+        raise TypeError("expected: either `source_data` or `source_path`; got: both")
+    elif source_data is not None:
+
+        def source_reader() -> BinaryIO:
+            return BytesIO(source_data)
+    elif source_path is not None:
+
+        def source_reader() -> BinaryIO:
+            return open(source_path, "rb")
+    else:
+        raise TypeError("expected: either `source_data` or `source_path`; got: neither")
+
+    if target_path is None:
+        with source_reader() as source_file, BytesIO() as memory_file:
+            _remove_png_chunks(names, source_file, memory_file)
+            return memory_file.getvalue()
+    else:
+        with source_reader() as source_file, open(target_path, "wb") as target_file:
+            _remove_png_chunks(names, source_file, target_file)
+            return None
+
+
+class _Chunk:
+    __slots__ = ("length", "name", "data", "crc")
+
+    length: int
+    name: bytes
+    data: bytes
+    crc: bytes
+
+    def __init__(self, length: int, name: bytes, data: bytes, crc: bytes):
+        self.length = length
+        self.name = name
+        self.data = data
+        self.crc = crc
+
+
+def _read_signature(f: BinaryIO) -> None:
+    "Reads and checks PNG signature (first 8 bytes)."
+
+    signature = f.read(8)
+    if signature != b"\x89PNG\r\n\x1a\n":
+        raise ValueError("not a valid PNG file")
+
+
+def _read_chunk(f: BinaryIO) -> Optional[_Chunk]:
+    "Reads and parses a PNG chunk such as `IHDR` or `tEXt`."
+
+    length_bytes = f.read(4)
+    if not length_bytes:
+        return None
+
+    if len(length_bytes) != 4:
+        raise ValueError("insufficient bytes to read chunk length")
+
+    length = int.from_bytes(length_bytes, "big")
+
+    data_length = 4 + length + 4
+    data_bytes = f.read(data_length)
+    if len(data_bytes) != data_length:
+        raise ValueError(f"insufficient bytes to read chunk data of length {length}")
+
+    chunk_type = data_bytes[0:4]
+    chunk_data = data_bytes[4:-4]
+    crc = data_bytes[-4:]
+
+    return _Chunk(length, chunk_type, chunk_data, crc)
+
+
+def _write_chunk(f: BinaryIO, chunk: _Chunk) -> None:
+    f.write(chunk.length.to_bytes(4, "big"))
+    f.write(chunk.name)
+    f.write(chunk.data)
+    f.write(chunk.crc)
+
+
+def _get_png_dimensions(source_file: BinaryIO) -> tuple[int, int]:
+    """
+    Returns the width and height of a PNG image inspecting its header.
+
+    :param source_file: A binary file opened for reading that contains PNG image data.
+    :returns: A tuple of the image's width and height in pixels.
+    """
+
+    _read_signature(source_file)
+
+    # validate IHDR chunk
+    ihdr = _read_chunk(source_file)
+    if ihdr is None:
+        raise ValueError("missing IHDR chunk")
+
+    if ihdr.length != 13:
+        raise ValueError("invalid chunk length")
+    if ihdr.name != b"IHDR":
+        raise ValueError(f"expected: IHDR chunk; got: {ihdr.name!r}")
+
+    (width, height, bit_depth, color_type, compression, filter, interlace) = unpack(">IIBBBBB", ihdr.data)
+    return width, height
+
+
+def _remove_png_chunks(names: Iterable[str], source_file: BinaryIO, target_file: BinaryIO) -> None:
+    """
+    Rewrites a PNG file by removing chunks with the specified names.
+
+    :param source_file: A binary file opened for reading that contains PNG image data.
+    :param target_file: A binary file opened for writing to receive PNG image data.
+    """
+
+    exclude_set = set(name.encode("ascii") for name in names)
+
+    _read_signature(source_file)
+    target_file.write(b"\x89PNG\r\n\x1a\n")
+
+    while True:
+        chunk = _read_chunk(source_file)
+        if chunk is None:
+            break
+
+        if chunk.name not in exclude_set:
+            _write_chunk(target_file, chunk)

md2conf/local.py

@@ -83,9 +83,9 @@ class LocalProcessor(Processor):
         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():
+        for name, file_data in document.embedded_files.items():
             with open(csf_dir / name, "wb") as f:
-                f.write(data)
+                f.write(file_data.data)
 
 
 class LocalProcessorFactory(ProcessorFactory):

md2conf/markdown.py

@@ -76,9 +76,11 @@ _CONVERTER = markdown.Markdown(
         "markdown.extensions.tables",
         "md_in_html",
         "pymdownx.arithmatex",
+        "pymdownx.caret",
         "pymdownx.emoji",
         "pymdownx.highlight",  # required by `pymdownx.superfences`
         "pymdownx.magiclink",
+        "pymdownx.mark",
         "pymdownx.superfences",
         "pymdownx.tilde",
         "sane_lists",
@@ -86,7 +88,7 @@ _CONVERTER = markdown.Markdown(
     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.emoji": {"emoji_generator": _emoji_generator},
         "pymdownx.highlight": {
             "use_pygments": False,
         },

md2conf/mermaid.py

@@ -47,14 +47,12 @@ def has_mmdc() -> bool:
 def render_diagram(source: str, output_format: Literal["png", "svg"] = "png") -> bytes:
     "Generates a PNG or SVG image from a Mermaid diagram source."
 
-    filename = f"tmp_mermaid.{output_format}"
-
     cmd = [
         get_mmdc(),
         "--input",
         "-",
         "--output",
-        filename,
+        "-",
         "--outputFormat",
         output_format,
         "--backgroundColor",
@@ -66,27 +64,23 @@ def render_diagram(source: str, output_format: Literal["png", "svg"] = "png") ->
     if is_docker():
         cmd.extend(["-p", os.path.join(root, "puppeteer-config.json")])
     LOGGER.debug("Executing: %s", " ".join(cmd))
-    try:
-        proc = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stdin=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=False,
-        )
-        stdout, stderr = proc.communicate(input=source.encode("utf-8"))
-        if proc.returncode:
-            messages = [f"failed to convert Mermaid 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 RuntimeError("\n".join(messages))
-        with open(filename, "rb") as image:
-            return image.read()
-
-    finally:
-        if os.path.exists(filename):
-            os.remove(filename)
+
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=False,
+    )
+    stdout, stderr = proc.communicate(input=source.encode("utf-8"))
+    if proc.returncode:
+        messages = [f"failed to convert Mermaid 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 RuntimeError("\n".join(messages))
+
+    return stdout

md2conf/text.py

@@ -0,0 +1,54 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+
+def wrap_text(text: str, line_length: int = 160) -> str:
+    """
+    Wraps text by replacing individual whitespace characters with a linefeed such that lines in the output honor the specified line length.
+
+    :param text: Input text, optionally with existing UNIX line endings.
+    :param line_length: Desired line length.
+    :returns: Wrapped output text. Long words that exceed the specified line length are not broken.
+    """
+
+    if line_length < 1:
+        raise ValueError("expected: line_length > 0")
+
+    input = text.encode("utf-8")
+    output = bytearray(len(input))
+    pos = 0
+    length = len(input)
+
+    while pos < length:
+        end = min(pos + line_length, length)
+
+        # find any linefeed already in input
+        left = pos
+        while left < end and input[left] != 0x0A:
+            left += 1
+        if left != end:
+            output[pos : left + 1] = input[pos : left + 1]
+            pos = left + 1  # include linefeed
+            continue
+
+        # find the nearest whitespace before end of line
+        right = end
+        while right > pos and input[right - 1] not in b"\t\v\f\r ":
+            right -= 1
+
+        if right == pos or end == length:
+            # no whitespace found or at end of input; copy the rest
+            output[pos:end] = input[pos:end]
+            pos = end
+        else:
+            # replace the whitespace with a newline
+            output[pos : right - 1] = input[pos : right - 1]
+            output[right - 1] = 0x0A  # linefeed '\n'
+            pos = right  # skip the whitespace (already replaced)
+
+    return output.decode("utf-8")

md2conf/xml.py

@@ -87,6 +87,8 @@ def is_xml_equal(
     """
     Compare two XML documents for equivalence, ignoring leading/trailing whitespace differences and attribute definition order.
 
+    Elements may be excluded, in which case they compare equal to any element of the same type that has the same tail text.
+
     :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.
@@ -101,3 +103,38 @@ def element_to_text(node: ET._Element) -> str:
     "Returns all text contained in an element as a concatenated string."
 
     return "".join(node.itertext()).strip()
+
+
+def unwrap_substitute(name: str, root: ET._Element) -> None:
+    """
+    Substitutes all occurrences of an element with its contents.
+
+    :param name: Element tag name to find and replace.
+    :param root: Top-most element at which to start.
+    """
+
+    for node in root.iterdescendants(name):
+        if node.text:
+            # append first piece of text in this element at the end of previous sibling, or text contained by parent
+            if (prev_node := node.getprevious()) is not None:
+                prev_node.tail = (prev_node.tail or "") + node.text
+            elif (parent_node := node.getparent()) is not None:  # always true except for root
+                parent_node.text = (parent_node.text or "") + node.text
+            else:
+                raise NotImplementedError("must always have a previous sibling or a parent")
+        if node.tail:
+            if len(node) > 0:
+                # append text immediately following the closing tag of this element to the last child element of this element
+                last_node = node[-1]
+                last_node.tail = (last_node.tail or "") + node.tail
+            else:  # node has no child elements, only text
+                if (prev_node := node.getprevious()) is not None:
+                    prev_node.tail = (prev_node.tail or "") + node.tail
+                elif (parent_node := node.getparent()) is not None:  # always true except for root
+                    parent_node.text = (parent_node.text or "") + node.tail
+                else:
+                    raise NotImplementedError("must always have a previous sibling or a parent")
+        for child in node.iterchildren(reversed=True):
+            node.addnext(child)
+        if (parent_node := node.getparent()) is not None:  # always true except for root
+            parent_node.remove(node)

markdown_to_confluence-0.4.4.dist-info/RECORD

@@ -1,31 +0,0 @@
-markdown_to_confluence-0.4.4.dist-info/licenses/LICENSE,sha256=Pv43so2bPfmKhmsrmXFyAvS7M30-1i1tzjz6-dfhyOo,1077
-md2conf/__init__.py,sha256=nfPrvkkECt_Szpol9kTkli5cL-tFqFzn8JefKlCyb3s,402
-md2conf/__main__.py,sha256=RImfFrO2m9C5iebmBrHKlLjosy_A8AY4O7PK9CmiWSw,11120
-md2conf/api.py,sha256=-UrtFi3pFOVMsYj7VTgCqHIBinHsSLUucmGSeureEaE,37253
-md2conf/application.py,sha256=MBV4Lg6s40Q0Z4SK7W9cSo-k2A-ckmu8wosuwo_2XWM,8301
-md2conf/collection.py,sha256=EobgMRJgkYloWlY03NZJ52MRC_SGLpTVCHkltDbQyt0,837
-md2conf/converter.py,sha256=WNfxGEacibINQYCZXszaMoUvJIP4Rq8IDMjz5RSH0IY,51162
-md2conf/csf.py,sha256=tEbl3e5UQmbRSQK3lQqmpADoy638tlJihutqJoWhumA,4374
-md2conf/domain.py,sha256=tA9V0vb5Vo9Nt0eQvwAFARaM9TX88LBVQ73nVvdcaqA,1851
-md2conf/drawio.py,sha256=P_t7Wp7Tg9XkZM2ZchWCWWEdBaU1KgZ_YX9ZlkZo4Dk,8293
-md2conf/entities.dtd,sha256=M6NzqL5N7dPs_eUA_6sDsiSLzDaAacrx9LdttiufvYU,30215
-md2conf/extra.py,sha256=VuMxuOnnC2Qwy6y52ukIxsaYhrZArRqMmRHRE4QZl8g,687
-md2conf/local.py,sha256=mUe2QBHhdZesygmYq5kXyGyl_ZmfUECgxDxylQwTa7g,3732
-md2conf/markdown.py,sha256=z9sVTA_Hcn551DZgdO7Nbod-IZ-43B4eJLklrYQ2KYI,3141
-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=z2d2KMPEYWaxflOtH2UTwrjzpPU8TtLSEUvor85ez1Q,9732
-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/toc.py,sha256=hpqqDbFgNJg5-ul8qWjOglI3Am0sbwR-TLwGN5G9Qo0,2447
-md2conf/uri.py,sha256=KbLBdRFtZTQTZd8b4j0LtE8Pb68Ly0WkemF4iW-EAB4,1158
-md2conf/xml.py,sha256=ERkGLuJgVFrOkzsMLd1RHU5SGFfFSxxNFZAeKrfdtRs,3454
-markdown_to_confluence-0.4.4.dist-info/METADATA,sha256=Ql8vwKX6wtZNtUVoT0z35HgiFQcW-fFWsWFUMLkNErw,32306
-markdown_to_confluence-0.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_to_confluence-0.4.4.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
-markdown_to_confluence-0.4.4.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
-markdown_to_confluence-0.4.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-markdown_to_confluence-0.4.4.dist-info/RECORD,,