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

md2conf/drawio.py

@@ -0,0 +1,222 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import base64
+import typing
+import zlib
+from pathlib import Path
+from struct import unpack
+from urllib.parse import unquote_to_bytes
+
+import lxml.etree as ET
+
+
+class DrawioError(ValueError):
+    """
+    Raised when the input does not adhere to the draw.io document format, or processing the input into a draw.io diagram fails.
+
+    Examples include:
+
+    * invalid or corrupt PNG file
+    * PNG chunk with embedded diagram data not found
+    * the structure of the outer XML does not match the expected format
+    * URL decoding error
+    * decompression error during INFLATE
+    """
+
+
+def inflate(data: bytes) -> bytes:
+    """
+    Decompresses (inflates) data compressed using the raw DEFLATE algorithm.
+
+    :param data: Compressed data using raw DEFLATE format.
+    :returns: Uncompressed data.
+    """
+
+    # -zlib.MAX_WBITS indicates raw DEFLATE stream (no zlib/gzip headers)
+    return zlib.decompress(data, -zlib.MAX_WBITS)
+
+
+def decompress_diagram(xml_data: typing.Union[bytes, str]) -> ET._Element:
+    """
+    Decompresses the text content of the `<diagram>` element in a draw.io XML document.
+
+    If the data is not compressed, the de-serialized XML element tree is returned.
+
+    Expected input (as `bytes` or `str`):
+    ```
+    <mxfile>
+        <diagram>... ENCODED_COMPRESSED_DATA ...</diagram>
+    </mxfile>
+    ```
+
+    Output (as XML element tree):
+    ```
+    <mxfile>
+        <diagram>
+            <mxGraphModel>
+                <root>
+                    ...
+                </root>
+            </mxGraphModel>
+        </diagram>
+    </mxfile>
+    ```
+
+    :param xml_data: The serialized XML document.
+    :returns: XML element tree with the text contained within the `<diagram>` element expanded into a sub-tree.
+    """
+
+    try:
+        root = ET.fromstring(xml_data)
+    except ET.ParseError as e:
+        raise DrawioError("invalid outer XML") from e
+
+    if root.tag != "mxfile":
+        raise DrawioError("root element is not `<mxfile>`")
+
+    diagram_elem = root.find("diagram")
+    if diagram_elem is None:
+        raise DrawioError("`<diagram>` element not found")
+
+    if len(diagram_elem) > 0:
+        # already decompressed
+        return root
+
+    if diagram_elem.text is None:
+        raise DrawioError("`<diagram>` element has no data")
+
+    # reverse base64-encoding of inner data
+    try:
+        base64_decoded = base64.b64decode(diagram_elem.text, validate=True)
+    except ValueError as e:
+        raise DrawioError("raw text data in `<diagram>` element is not properly Base64-encoded") from e
+
+    # decompress inner data
+    try:
+        embedded_data = inflate(base64_decoded)
+    except zlib.error as e:
+        raise DrawioError("`<diagram>` element text data cannot be decompressed using INFLATE") from e
+
+    # reverse URL-encoding of inner data
+    try:
+        url_decoded = unquote_to_bytes(embedded_data)
+    except ValueError as e:
+        raise DrawioError("decompressed data in `<diagram>` element is not properly URL-encoded") from e
+
+    # create sub-tree from decompressed data
+    try:
+        tree = ET.fromstring(url_decoded)
+    except ET.ParseError as e:
+        raise DrawioError("invalid inner XML extracted from `<diagram>` element") from e
+
+    # update document
+    diagram_elem.text = None
+    diagram_elem.append(tree)
+
+    return root
+
+
+def extract_xml_from_png(png_data: bytes) -> ET._Element:
+    """
+    Extracts an editable draw.io diagram from a PNG file.
+
+    :param png_data: PNG binary data, with an embedded draw.io diagram.
+    :returns: XML element tree of a draw.io diagram.
+    """
+
+    # PNG signature is always the first 8 bytes
+    png_signature = b"\x89PNG\r\n\x1a\n"
+    if not png_data.startswith(png_signature):
+        raise DrawioError("not a valid PNG file")
+
+    offset = len(png_signature)
+    while offset < len(png_data):
+        if offset + 8 > len(png_data):
+            raise DrawioError("corrupted PNG: incomplete chunk header")
+
+        # read chunk length (4 bytes) and type (4 bytes)
+        (length,) = unpack(">I", png_data[offset : offset + 4])
+        chunk_type = png_data[offset + 4 : offset + 8]
+        offset += 8
+
+        if offset + length + 4 > len(png_data):
+            raise DrawioError(f"corrupted PNG: incomplete data for chunk {chunk_type.decode('ascii')}")
+
+        # read chunk data
+        chunk_data = png_data[offset : offset + length]
+        offset += length
+
+        # skip CRC (4 bytes)
+        offset += 4
+
+        # extracts draw.io diagram data from a `tEXt` chunk with the keyword `mxfile` embedded in a PNG
+        if chunk_type != b"tEXt":
+            continue
+
+        # format: keyword\0text
+        null_pos = chunk_data.find(b"\x00")
+        if null_pos < 0:
+            raise DrawioError("corrupted PNG: tEXt chunk missing keyword")
+
+        keyword = chunk_data[:null_pos].decode("latin1")
+        if keyword != "mxfile":
+            continue
+
+        textual_data = chunk_data[null_pos + 1 :]
+
+        try:
+            url_decoded = unquote_to_bytes(textual_data)
+        except ValueError as e:
+            raise DrawioError("data in `tEXt` chunk is not properly URL-encoded") from e
+
+        # decompress data embedded in the outer XML wrapper
+        return decompress_diagram(url_decoded)
+
+    # matching `tEXt` chunk not found
+    raise DrawioError("not a PNG file made with draw.io")
+
+
+def extract_xml_from_svg(svg_data: bytes) -> ET._Element:
+    """
+    Extracts an editable draw.io diagram from an SVG file.
+
+    :param svg_data: SVG XML data, with an embedded draw.io diagram.
+    :returns: XML element tree of a draw.io diagram.
+    """
+
+    try:
+        root = ET.fromstring(svg_data)
+    except ET.ParseError as e:
+        raise DrawioError("invalid SVG XML") from e
+
+    content = root.attrib.get("content")
+    if content is None:
+        raise DrawioError("SVG root element has no attribute `content`")
+
+    return decompress_diagram(content)
+
+
+def extract_diagram(path: Path) -> bytes:
+    """
+    Extracts an editable draw.io diagram from a PNG file.
+
+    :param path: Path to a PNG or SVG file with an embedded draw.io diagram.
+    :returns: XML data of a draw.io diagram as bytes.
+    """
+
+    if path.name.endswith(".drawio.png"):
+        with open(path, "rb") as png_file:
+            root = extract_xml_from_png(png_file.read())
+    elif path.name.endswith(".drawio.svg"):
+        with open(path, "rb") as svg_file:
+            root = extract_xml_from_svg(svg_file.read())
+    else:
+        raise DrawioError(f"unrecognized file type for {path.name}")
+
+    return ET.tostring(root, encoding="utf8", method="xml")

md2conf/local.py

@@ -66,6 +66,7 @@ class LocalProcessor(Processor):
                     page_id=page_id,
                     space_key=node.space_key or self.site.space_key or "HOME",
                     title=node.title or "",
+                    synchronized=node.synchronized,
                 ),
             )
 

md2conf/matcher.py

@@ -10,14 +10,57 @@ import os.path
 from dataclasses import dataclass
 from fnmatch import fnmatch
 from pathlib import Path
-from typing import Iterable, Optional, Union, overload
+from typing import Iterable, Optional, Union, final, overload
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=True)
+class _BaseEntry:
+    """
+    Represents a file or directory entry.
+
+    Entries are primarily sorted alphabetically case-insensitive.
+    When two items are equal case-insensitive, conflicting items are put in case-sensitive order.
+
+    :param name: Name of the file-system entry.
+    """
+
+    name: str
+
+    @property
+    def lower_name(self) -> str:
+        return self.name.lower()
+
+    def __lt__(self, other: "_BaseEntry") -> bool:
+        return (self.lower_name, self.name) < (other.lower_name, other.name)
+
+    def __le__(self, other: "_BaseEntry") -> bool:
+        return (self.lower_name, self.name) <= (other.lower_name, other.name)
+
+    def __ge__(self, other: "_BaseEntry") -> bool:
+        return (self.lower_name, self.name) >= (other.lower_name, other.name)
+
+    def __gt__(self, other: "_BaseEntry") -> bool:
+        return (self.lower_name, self.name) > (other.lower_name, other.name)
+
+
+@final
+class FileEntry(_BaseEntry):
+    pass
+
+
+@final
+class DirectoryEntry(_BaseEntry):
+    pass
+
+
+@dataclass(frozen=True, eq=True)
 class Entry:
     """
     Represents a file or directory entry.
 
+    When sorted, directories come before files and items are primarily arranged in alphabetical order case-insensitive.
+    When two items are equal case-insensitive, conflicting items are put in case-sensitive order.
+
     :param name: Name of the file-system entry to match against the rule-set.
     :param is_dir: True if the entry is a directory.
     """
@@ -25,6 +68,22 @@ class Entry:
     name: str
     is_dir: bool
 
+    @property
+    def lower_name(self) -> str:
+        return self.name.lower()
+
+    def __lt__(self, other: "Entry") -> bool:
+        return (not self.is_dir, self.lower_name, self.name) < (not other.is_dir, other.lower_name, other.name)
+
+    def __le__(self, other: "Entry") -> bool:
+        return (not self.is_dir, self.lower_name, self.name) <= (not other.is_dir, other.lower_name, other.name)
+
+    def __ge__(self, other: "Entry") -> bool:
+        return (not self.is_dir, self.lower_name, self.name) >= (not other.is_dir, other.lower_name, other.name)
+
+    def __gt__(self, other: "Entry") -> bool:
+        return (not self.is_dir, self.lower_name, self.name) > (not other.is_dir, other.lower_name, other.name)
+
 
 @dataclass
 class MatcherOptions:
@@ -146,9 +205,9 @@ class Matcher:
         :returns: A filtered list of names that didn't match any of the exclusion rules.
         """
 
-        return [entry for entry in entries if self.is_included(entry)]
+        return sorted(entry for entry in entries if self.is_included(entry))
 
-    def scandir(self, path: Path) -> list[Entry]:
+    def listing(self, path: Path) -> list[Entry]:
         """
         Returns only those entries in a directory whose name doesn't match any of the exclusion rules.
 

md2conf/metadata.py

@@ -33,8 +33,10 @@ class ConfluencePageMetadata:
     :param page_id: Confluence page ID.
     :param space_key: Confluence space key.
     :param title: Document title.
+    :param synchronized: True if the document content is parsed and synchronized with Confluence.
     """
 
     page_id: str
     space_key: str
     title: str
+    synchronized: bool

md2conf/processor.py

@@ -15,7 +15,7 @@ from typing import Iterable, Optional
 
 from .collection import ConfluencePageCollection
 from .converter import ConfluenceDocument, ConfluenceDocumentOptions, ConfluencePageID
-from .matcher import Matcher, MatcherOptions
+from .matcher import DirectoryEntry, FileEntry, Matcher, MatcherOptions
 from .metadata import ConfluenceSiteMetadata
 from .properties import ArgumentError
 from .scanner import Scanner
@@ -28,6 +28,7 @@ class DocumentNode:
     page_id: Optional[str]
     space_key: Optional[str]
     title: Optional[str]
+    synchronized: bool
 
     _children: list["DocumentNode"]
 
@@ -35,13 +36,15 @@ class DocumentNode:
         self,
         absolute_path: Path,
         page_id: Optional[str],
-        space_key: Optional[str] = None,
-        title: Optional[str] = None,
+        space_key: Optional[str],
+        title: Optional[str],
+        synchronized: bool,
     ):
         self.absolute_path = absolute_path
         self.page_id = page_id
         self.space_key = space_key
         self.title = title
+        self.synchronized = synchronized
         self._children = []
 
     def count(self) -> int:
@@ -98,16 +101,11 @@ class Processor:
         local_dir = local_dir.resolve(True)
         LOGGER.info("Processing directory: %s", local_dir)
 
-        # Step 1: build index of all Markdown files in directory hierarchy
+        # build index of all Markdown files in directory hierarchy
         root = self._index_directory(local_dir, None)
         LOGGER.info("Indexed %d document(s)", root.count())
 
-        # Step 2: synchronize directory tree structure with page hierarchy in space
-        self._synchronize_tree(root, self.options.root_page_id)
-
-        # Step 3: synchronize files in directory hierarchy with pages in space
-        for path, metadata in self.page_metadata.items():
-            self._synchronize_page(path, ConfluencePageID(metadata.page_id))
+        self._process_items(root)
 
     def process_page(self, path: Path) -> None:
         """
@@ -115,16 +113,22 @@ class Processor:
         """
 
         LOGGER.info("Processing page: %s", path)
-
-        # Step 1: parse Markdown file
         root = self._index_file(path)
 
-        # Step 2: find matching page in Confluence
+        self._process_items(root)
+
+    def _process_items(self, root: DocumentNode) -> None:
+        """
+        Processes a sub-tree rooted at an ancestor node.
+        """
+
+        # synchronize directory tree structure with page hierarchy in space (find matching pages in Confluence)
         self._synchronize_tree(root, self.options.root_page_id)
 
-        # Step 3: synchronize document with page in space
+        # synchronize files in directory hierarchy with pages in space
         for path, metadata in self.page_metadata.items():
-            self._synchronize_page(path, ConfluencePageID(metadata.page_id))
+            if metadata.synchronized:
+                self._synchronize_page(path, ConfluencePageID(metadata.page_id))
 
     def _synchronize_page(self, path: Path, page_id: ConfluencePageID) -> None:
         """
@@ -161,36 +165,40 @@ class Processor:
 
         matcher = Matcher(MatcherOptions(source=".mdignore", extension="md"), local_dir)
 
-        files: list[Path] = []
-        directories: list[Path] = []
+        files: list[FileEntry] = []
+        directories: list[DirectoryEntry] = []
         for entry in os.scandir(local_dir):
             if matcher.is_excluded(entry):
                 continue
 
             if entry.is_file():
-                files.append(local_dir / entry.name)
+                files.append(FileEntry(entry.name))
             elif entry.is_dir():
-                directories.append(local_dir / entry.name)
+                directories.append(DirectoryEntry(entry.name))
+
+        files.sort()
+        directories.sort()
 
         # make page act as parent node
         parent_doc: Optional[Path] = None
-        if (local_dir / "index.md") in files:
+        if FileEntry("index.md") in files:
             parent_doc = local_dir / "index.md"
-        elif (local_dir / "README.md") in files:
+        elif FileEntry("README.md") in files:
             parent_doc = local_dir / "README.md"
-        elif (local_dir / f"{local_dir.name}.md") in files:
+        elif FileEntry(f"{local_dir.name}.md") in files:
             parent_doc = local_dir / f"{local_dir.name}.md"
 
         if parent_doc is None and self.options.keep_hierarchy:
             parent_doc = local_dir / "index.md"
 
             # create a blank page for directory entry
-            with open(parent_doc, "w"):
-                pass
+            with open(parent_doc, "w") as f:
+                print("[[_LISTING_]]", file=f)
 
         if parent_doc is not None:
-            if parent_doc in files:
-                files.remove(parent_doc)
+            parent_entry = FileEntry(parent_doc.name)
+            if parent_entry in files:
+                files.remove(parent_entry)
 
             # promote Markdown document in directory as parent page in Confluence
             node = self._index_file(parent_doc)
@@ -201,11 +209,11 @@ class Processor:
             raise ArgumentError(f"root page requires corresponding top-level Markdown document in {local_dir}")
 
         for file in files:
-            node = self._index_file(file)
+            node = self._index_file(local_dir / Path(file.name))
             parent.add_child(node)
 
         for directory in directories:
-            self._index_directory(directory, parent)
+            self._index_directory(local_dir / Path(directory.name), parent)
 
         return parent
 
@@ -224,6 +232,7 @@ class Processor:
             page_id=document.page_id,
             space_key=document.space_key,
             title=document.title,
+            synchronized=document.synchronized if document.synchronized is not None else True,
         )
 
     def _generate_hash(self, absolute_path: Path) -> str:

md2conf/scanner.py

@@ -69,6 +69,7 @@ class DocumentProperties:
     :param generated_by: Text identifying the tool that generated the document.
     :param title: The title extracted from front-matter.
     :param tags: A list of tags (content labels) extracted from front-matter.
+    :param synchronized: True if the document content is parsed and synchronized with Confluence.
     :param properties: A dictionary of key-value pairs extracted from front-matter to apply as page properties.
     """
 
@@ -79,6 +80,7 @@ class DocumentProperties:
     generated_by: Optional[str]
     title: Optional[str]
     tags: Optional[list[str]]
+    synchronized: Optional[bool]
     properties: Optional[dict[str, JsonType]]
 
 
@@ -92,6 +94,7 @@ class ScannedDocument:
     :param generated_by: Text identifying the tool that generated the document.
     :param title: The title extracted from front-matter.
     :param tags: A list of tags (content labels) extracted from front-matter.
+    :param synchronized: True if the document content is parsed and synchronized with Confluence.
     :param properties: A dictionary of key-value pairs extracted from front-matter to apply as page properties.
     :param text: Text that remains after front-matter and inline properties have been extracted.
     """
@@ -101,6 +104,7 @@ class ScannedDocument:
     generated_by: Optional[str]
     title: Optional[str]
     tags: Optional[list[str]]
+    synchronized: Optional[bool]
     properties: Optional[dict[str, JsonType]]
     text: str
 
@@ -126,6 +130,7 @@ class Scanner:
 
         title: Optional[str] = None
         tags: Optional[list[str]] = None
+        synchronized: Optional[bool] = None
         properties: Optional[dict[str, JsonType]] = None
 
         # extract front-matter
@@ -137,6 +142,7 @@ class Scanner:
             generated_by = generated_by or p.generated_by
             title = p.title
             tags = p.tags
+            synchronized = p.synchronized
             properties = p.properties
 
         return ScannedDocument(
@@ -145,6 +151,7 @@ class Scanner:
             generated_by=generated_by,
             title=title,
             tags=tags,
+            synchronized=synchronized,
             properties=properties,
             text=text,
         )

md2conf/xml.py

@@ -0,0 +1,70 @@
+from typing import Iterable, Optional, Union
+
+import lxml.etree as ET
+
+
+def _attrs_equal_excluding(attrs1: ET._Attrib, attrs2: ET._Attrib, exclude: set[Union[str, ET.QName]]) -> bool:
+    """
+    Compares two dictionary objects, excluding keys in the skip set.
+    """
+
+    # create key sets to compare, excluding keys to be skipped
+    keys1 = {k for k in attrs1.keys() if k not in exclude}
+    keys2 = {k for k in attrs2.keys() if k not in exclude}
+    if keys1 != keys2:
+        return False
+
+    # compare values for each key
+    for key in keys1:
+        if attrs1.get(key) != attrs2.get(key):
+            return False
+
+    return True
+
+
+class ElementComparator:
+    skip_attributes: set[Union[str, ET.QName]]
+
+    def __init__(self, *, skip_attributes: Optional[Iterable[Union[str, ET.QName]]] = None):
+        self.skip_attributes = set(skip_attributes) if skip_attributes else set()
+
+    def is_equal(self, e1: ET._Element, e2: ET._Element) -> bool:
+        """
+        Recursively check if two XML elements are equal.
+        """
+
+        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
+
+        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
+
+        if not _attrs_equal_excluding(e1.attrib, e2.attrib, self.skip_attributes):
+            return False
+        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,
+) -> 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.
+    :returns: True if equivalent, False otherwise.
+    """
+
+    return ElementComparator(skip_attributes=skip_attributes).is_equal(tree1, tree2)

markdown_to_confluence-0.4.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-markdown_to_confluence-0.4.1.dist-info/licenses/LICENSE,sha256=Pv43so2bPfmKhmsrmXFyAvS7M30-1i1tzjz6-dfhyOo,1077
-md2conf/__init__.py,sha256=K6ZE42N5KJjN5o2GqIFa_lcPZvMMCXPMMRWEkvlmcp0,402
-md2conf/__main__.py,sha256=MJm9U75savKWKYm4dLREqlsyBWEqkTtaM4YTWkEeo0E,8388
-md2conf/api.py,sha256=RQ_nb0Z0VnhJma1BU9ABeb4MQZvZEfFS5mTXXKcY6bk,37584
-md2conf/application.py,sha256=cXYXYdEdmMXwhxF69eUiPPG2Ixt4xtlWHXa28wTq150,7571
-md2conf/collection.py,sha256=EAXuIFcIRBO-Giic2hdU2d4Hpj0_ZFBAWI3aKQ2fjrI,775
-md2conf/converter.py,sha256=x2LAY1Hpw5mTVFNJE5_Zm-o7p5y6TTds6KfrpdM5qQk,38823
-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=MVwGxy_n00uqCInLK8FVGaaVnaOp1nfn28PVrWz3cCQ,3496
-md2conf/matcher.py,sha256=izgL_MAMqbXjKPvAz3KpFv5OTDsaJ9GplTJbixrT3oY,4918
-md2conf/mermaid.py,sha256=f0x7ISj-41ZMh4zTAFPhIWwr94SDcsVZUc1NWqmH_G4,2508
-md2conf/metadata.py,sha256=TxgUrskqsWor_pvlQx-p86C0-0qRJ2aeQhuDcXU9Dpc,886
-md2conf/processor.py,sha256=yWVRYtbc9UHSUfRxqyPDsgeVqO7gx0s3RiGL1GzMotE,9405
-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=qXfnJkaEwDbz6G6Z9llqifBp2TLAlrXAIP4qkCbGdWo,4964
-markdown_to_confluence-0.4.1.dist-info/METADATA,sha256=rAXtL2mR1LHmc_pwkmnwrGpIDMEw-7kZjIJOnMi-NLA,24864
-markdown_to_confluence-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_to_confluence-0.4.1.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
-markdown_to_confluence-0.4.1.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
-markdown_to_confluence-0.4.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-markdown_to_confluence-0.4.1.dist-info/RECORD,,