html-to-markdown 1.9.0__py3-none-any.whl → 1.9.1__py3-none-any.whl

html_to_markdown/converters.py

@@ -211,9 +211,7 @@ def _convert_blockquote(*, text: str, tag: Tag, convert_as_inline: bool) -> str:
 
     cite_url = tag.get("cite")
 
-    # Check if this blockquote is inside a list item
     if _has_ancestor(tag, "li"):
-        # Indent the blockquote by 4 spaces
         lines = text.strip().split("\n")
         indented_lines = [f"    > {line}" if line.strip() else "" for line in lines]
         quote_text = "\n".join(indented_lines) + "\n\n"
@@ -290,16 +288,12 @@ def _convert_list(*, tag: Tag, text: str) -> str:
     if tag.next_sibling and getattr(tag.next_sibling, "name", None) not in {"ul", "ol"}:
         before_paragraph = True
 
-    # Check if this list is inside a list item
     if _has_ancestor(tag, "li"):
-        # This is a nested list - needs indentation
-        # But we need to check if it's the first element after a paragraph
         parent = tag.parent
         while parent and parent.name != "li":
             parent = parent.parent
 
         if parent:
-            # Check if there's a paragraph before this list
             prev_p = None
             for child in parent.children:
                 if hasattr(child, "name"):
@@ -309,7 +303,6 @@ def _convert_list(*, tag: Tag, text: str) -> str:
                         prev_p = child
 
             if prev_p:
-                # If there's a paragraph before, we need proper indentation
                 lines = text.strip().split("\n")
                 indented_lines = []
                 for line in lines:
@@ -318,9 +311,21 @@ def _convert_list(*, tag: Tag, text: str) -> str:
                     else:
                         indented_lines.append("")
                 return "\n" + "\n".join(indented_lines) + "\n"
-            # Otherwise use the original tab indentation
             return "\n" + indent(text=text, level=1).rstrip()
 
+    if tag.parent and tag.parent.name in {"ul", "ol"}:
+        lines = text.strip().split("\n")
+        indented_lines = []
+        for line in lines:
+            if line.strip():
+                indented_lines.append(f"    {line}")
+            else:
+                indented_lines.append("")
+        result = "\n".join(indented_lines)
+        if not result.endswith("\n"):
+            result += "\n"
+        return result
+
     return text + ("\n" if before_paragraph else "")
 
 
@@ -355,7 +360,6 @@ def _convert_li(*, tag: Tag, text: str, bullets: str) -> str:
 
         bullet = bullets[depth % len(bullets)]
 
-    # Check if the list item contains block-level elements (like <p>, <blockquote>, etc.)
     has_block_children = any(
         child.name in {"p", "blockquote", "pre", "ul", "ol", "div", "h1", "h2", "h3", "h4", "h5", "h6"}
         for child in tag.children
@@ -363,25 +367,18 @@ def _convert_li(*, tag: Tag, text: str, bullets: str) -> str:
     )
 
     if has_block_children:
-        # Handle multi-paragraph list items
-        # Split by double newlines (paragraph separators)
         paragraphs = text.strip().split("\n\n")
 
         if paragraphs:
-            # First paragraph goes directly after the bullet
             result_parts = [f"{bullet} {paragraphs[0].strip()}\n"]
 
-            # Subsequent paragraphs need to be indented and separated by blank lines
             for para in paragraphs[1:]:
                 if para.strip():
-                    # Add blank line before the paragraph
                     result_parts.append("\n")
-                    # Indent each line of the paragraph by 4 spaces
                     result_parts.extend(f"    {line}\n" for line in para.strip().split("\n") if line.strip())
 
             return "".join(result_parts)
 
-    # Simple case: no block elements, just inline content
     return "{} {}\n".format(bullet, (text or "").strip())
 
 
@@ -399,20 +396,15 @@ def _convert_p(*, wrap: bool, text: str, convert_as_inline: bool, wrap_width: in
 
     from html_to_markdown.processing import _has_ancestor  # noqa: PLC0415
 
-    # Check if this paragraph is inside a list item
     if _has_ancestor(tag, "li"):
-        # Check if this is the first paragraph in the list item
         parent = tag.parent
         while parent and parent.name != "li":
             parent = parent.parent
 
         if parent:
-            # Get all direct children that are paragraphs
             p_children = [child for child in parent.children if hasattr(child, "name") and child.name == "p"]
 
-            # If this is not the first paragraph, indent it
             if p_children and tag != p_children[0]:
-                # Indent all lines by 4 spaces
                 indented_lines = []
                 for line in text.split("\n"):
                     if line.strip():
@@ -480,13 +472,11 @@ def _convert_tr(*, tag: Tag, text: str) -> str:
     parent_name = tag.parent.name if tag.parent and hasattr(tag.parent, "name") else ""
     tag_grand_parent = tag.parent.parent if tag.parent else None
 
-    # Simple rowspan handling: if previous row had cells with rowspan, add empty cells
     if tag.previous_sibling and hasattr(tag.previous_sibling, "name") and tag.previous_sibling.name == "tr":
         prev_cells = cast("Tag", tag.previous_sibling).find_all(["td", "th"])
         rowspan_positions = []
         col_pos = 0
 
-        # Check which cells in previous row have rowspan > 1
         for prev_cell in prev_cells:
             rowspan = 1
             if (
@@ -497,10 +487,8 @@ def _convert_tr(*, tag: Tag, text: str) -> str:
                 rowspan = int(prev_cell["rowspan"])
 
             if rowspan > 1:
-                # This cell spans into current row
                 rowspan_positions.append(col_pos)
 
-            # Account for colspan
             colspan = 1
             if (
                 "colspan" in prev_cell.attrs
@@ -510,25 +498,22 @@ def _convert_tr(*, tag: Tag, text: str) -> str:
                 colspan = int(prev_cell["colspan"])
             col_pos += colspan
 
-        # If there are rowspan cells from previous row, add empty cells
         if rowspan_positions:
-            # Build new text with empty cells inserted
-            new_cells = []
+            converted_cells: list[str] = []
+            if text.strip():
+                parts = text.split("|")
+                converted_cells.extend(part.rstrip() + " |" for part in parts[:-1] if part)
+
+            new_cells: list[str] = []
             cell_index = 0
 
-            for pos in range(col_pos):  # Total columns
+            for pos in range(col_pos):
                 if pos in rowspan_positions:
-                    # Add empty cell for rowspan
                     new_cells.append(" |")
-                elif cell_index < len(cells):
-                    # Add actual cell content
-                    cell = cells[cell_index]
-                    cell_text = cell.get_text().strip().replace("\n", " ")
-                    colspan = _get_colspan(cell)
-                    new_cells.append(f" {cell_text} |" * colspan)
+                elif cell_index < len(converted_cells):
+                    new_cells.append(converted_cells[cell_index])
                     cell_index += 1
 
-            # Override text with new cell arrangement
             text = "".join(new_cells)
 
     is_headrow = (
@@ -644,8 +629,6 @@ def _convert_colgroup(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
         Empty string as colgroup has no Markdown representation.
     """
     _ = tag, text, convert_as_inline
-    # Colgroup and its contents (col elements) are purely presentational
-    # and have no equivalent in Markdown tables
     return ""
 
 
@@ -663,7 +646,6 @@ def _convert_col(*, tag: Tag, convert_as_inline: bool) -> str:
         Empty string as col has no Markdown representation.
     """
     _ = tag, convert_as_inline
-    # Col elements are self-closing and purely presentational
     return ""
 
 
@@ -696,7 +678,6 @@ def _convert_details(*, text: str, convert_as_inline: bool) -> str:
     if convert_as_inline:
         return text
 
-    # Details is a semantic container, return its content
     return _format_block_element(text)
 
 
@@ -713,7 +694,6 @@ def _convert_summary(*, text: str, convert_as_inline: bool) -> str:
     if convert_as_inline:
         return text
 
-    # Summary is like a heading/title
     return _format_wrapped_block(text, "**")
 
 
@@ -826,18 +806,15 @@ def _convert_media_element(*, tag: Tag, text: str, convert_as_inline: bool) -> s
     if not src and (source_tag := tag.find("source")) and isinstance(source_tag, Tag):
         src = source_tag.get("src", "")
 
-    # If we have a src, convert to a link
     if src and isinstance(src, str) and src.strip():
         link = f"[{src}]({src})"
         if convert_as_inline:
             return link
         result = f"{link}\n\n"
-        # Add fallback content if present
         if text.strip():
             result += f"{text.strip()}\n\n"
         return result
 
-    # No src, just return fallback content
     if text.strip():
         return _format_inline_or_block(text, convert_as_inline)
 
@@ -858,7 +835,6 @@ def _convert_iframe(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     _ = text
     src = tag.get("src", "")
 
-    # If we have a src, convert to a link
     if src and isinstance(src, str) and src.strip():
         link = f"[{src}]({src})"
         if convert_as_inline:
@@ -906,7 +882,6 @@ def _convert_time(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Time elements are semantic - just return the content
     return text.strip()
 
 
@@ -926,7 +901,6 @@ def _convert_data(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Data elements are semantic - just return the content
     return text.strip()
 
 
@@ -961,7 +935,6 @@ def _convert_form(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Forms are just containers, return their content
     return text
 
 
@@ -981,7 +954,6 @@ def _convert_fieldset(*, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Fieldsets are semantic groupings, return their content
     return text
 
 
@@ -1001,7 +973,6 @@ def _convert_legend(*, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Legend is like a heading/title for fieldsets
     return _format_wrapped_block(text, "**")
 
 
@@ -1017,7 +988,6 @@ def _convert_label(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
         The label text content.
     """
     _ = tag
-    # Labels are just text, return the content
     if not text.strip():
         return ""
 
@@ -1035,7 +1005,6 @@ def _convert_input_enhanced(*, tag: Tag, convert_as_inline: bool) -> str:
         Empty string since input elements have no Markdown representation.
     """
     _ = tag, convert_as_inline
-    # Input elements have no content and no Markdown equivalent
     return ""
 
 
@@ -1051,7 +1020,6 @@ def _convert_textarea(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
         The text content of the textarea.
     """
     _ = tag
-    # Return the text content, which is what the user entered
     if not text.strip():
         return ""
 
@@ -1070,17 +1038,13 @@ def _convert_select(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
         The text content (options) as a comma-separated list.
     """
     _ = tag
-    # Return the options as text
     if not text.strip():
         return ""
 
-    # In inline mode, show options separated by commas
     if convert_as_inline:
-        # Remove extra whitespace and join options
         options = [opt.strip() for opt in text.strip().split("\n") if opt.strip()]
         return ", ".join(options)
 
-    # In block mode, show as a list
     return _format_block_element(text)
 
 
@@ -1098,14 +1062,12 @@ def _convert_option(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Check if this option is selected
     selected = tag.get("selected") is not None
     content = text.strip()
 
     if convert_as_inline:
         return content
 
-    # In block mode, mark selected options
     if selected:
         return f"* {content}\n"
     return f"{content}\n"
@@ -1131,7 +1093,6 @@ def _convert_optgroup(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     label = tag.get("label", "")
     content = text.strip()
 
-    # If there's a label, show it as a heading
     if label and isinstance(label, str) and label.strip():
         return f"**{label.strip()}**\n{content}\n"
 
@@ -1150,7 +1111,6 @@ def _convert_button(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
         The button text content.
     """
     _ = tag
-    # Buttons are just interactive text, return the text content
     if not text.strip():
         return ""
 
@@ -1175,7 +1135,6 @@ def _convert_progress(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Progress elements convert to their text content
     return _format_block_element(text)
 
 
@@ -1197,7 +1156,6 @@ def _convert_meter(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Meter elements convert to their text content
     return _format_block_element(text)
 
 
@@ -1219,7 +1177,6 @@ def _convert_output(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Output elements convert to their text content
     return _format_block_element(text)
 
 
@@ -1241,7 +1198,6 @@ def _convert_datalist(*, tag: Tag, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Datalist shows options as a list
     return _format_block_element(text)
 
 
@@ -1352,7 +1308,6 @@ def _convert_dialog(*, text: str, convert_as_inline: bool, tag: Tag) -> str:
     if not text.strip():
         return ""
 
-    # Dialog is a semantic container, return its content
     return _format_block_element(text)
 
 
@@ -1374,7 +1329,6 @@ def _convert_menu(*, text: str, convert_as_inline: bool, tag: Tag) -> str:
     if not text.strip():
         return ""
 
-    # Menu is converted as a list
     return _format_block_element(text)
 
 
@@ -1396,8 +1350,6 @@ def _convert_figure(*, text: str, convert_as_inline: bool, tag: Tag) -> str:
     if convert_as_inline:
         return text
 
-    # Figure is a semantic container, return its content
-    # Make sure there's proper spacing after the figure content
     content = text.strip()
     if content and not content.endswith("\n\n"):
         if content.endswith("\n"):
@@ -1423,7 +1375,6 @@ def _convert_hgroup(*, text: str, convert_as_inline: bool) -> str:
     if not text.strip():
         return ""
 
-    # Hgroup is a semantic container for headings, return its content
     return text
 
 
@@ -1442,7 +1393,6 @@ def _convert_picture(*, text: str, convert_as_inline: bool, tag: Tag) -> str:
     if not text.strip():
         return ""
 
-    # Picture is a container for responsive images, only the img matters for Markdown
     return text.strip()
 
 

html_to_markdown/processing.py

@@ -195,18 +195,14 @@ def _process_tag(
 
     children = list(filter(lambda value: not isinstance(value, (Comment, Doctype)), tag.children))
 
-    # List of tags that return empty string when they have no content
     empty_when_no_content_tags = {"abbr", "var", "ins", "dfn", "time", "data", "cite", "q", "mark", "small", "u"}
 
     for i, el in enumerate(children):
         if isinstance(el, NavigableString):
-            # Check if this is whitespace between empty elements
             if el.strip() == "" and i > 0 and i < len(children) - 1:
                 prev_el = children[i - 1]
                 next_el = children[i + 1]
 
-                # If previous element was a tag that produced empty output
-                # and next element is also a tag that could be empty, skip this whitespace
                 if (
                     isinstance(prev_el, Tag)
                     and isinstance(next_el, Tag)
@@ -214,7 +210,6 @@ def _process_tag(
                     and next_el.name.lower() in empty_when_no_content_tags
                     and not prev_el.get_text().strip()
                 ):
-                    # Previous tag is empty and next could be empty too, skip this whitespace
                     continue
 
             text_parts.append(
@@ -281,14 +276,10 @@ def _process_text(
             break
 
     if "pre" not in ancestor_names:
-        # Special case: if the text is only whitespace
         if text.strip() == "":
-            # If it contains newlines, it's probably indentation whitespace, return empty
             if "\n" in text:
                 text = ""
             else:
-                # Check if this whitespace is between block elements
-                # Define block elements that should not have whitespace between them
                 block_elements = {
                     "p",
                     "ul",
@@ -320,7 +311,6 @@ def _process_text(
                 prev_sibling = el.previous_sibling
                 next_sibling = el.next_sibling
 
-                # Check if whitespace is between block elements
                 if (
                     prev_sibling
                     and hasattr(prev_sibling, "name")
@@ -329,10 +319,8 @@ def _process_text(
                     and hasattr(next_sibling, "name")
                     and next_sibling.name in block_elements
                 ):
-                    # Remove whitespace between block elements
                     text = ""
                 else:
-                    # Otherwise it's inline whitespace, normalize to single space
                     text = " " if text else ""
         else:
             has_leading_space = text.startswith((" ", "\t"))
@@ -470,7 +458,6 @@ def _extract_metadata(soup: BeautifulSoup) -> dict[str, str]:
     if canonical and isinstance(canonical, Tag) and isinstance(canonical["href"], str):
         metadata["canonical"] = canonical["href"]
 
-    # Extract link relations
     link_relations = {"author", "license", "alternate"}
     for rel_type in link_relations:
         link = soup.find("link", rel=rel_type, href=True)
@@ -595,8 +582,6 @@ def convert_to_markdown(
         if strip_newlines:
             source = source.replace("\n", " ").replace("\r", " ")
 
-        # Fix lxml parsing of void elements like <wbr>
-        # lxml incorrectly treats them as container tags
         source = re.sub(r"<wbr\s*>", "<wbr />", source, flags=re.IGNORECASE)
 
         if preprocess_html and create_preprocessor is not None and preprocess_fn is not None:
@@ -737,7 +722,6 @@ def convert_to_markdown(
         if leading_whitespace_match:
             leading_whitespace = leading_whitespace_match.group(0)
 
-            # Check if input contains list or heading tags
             list_heading_tags = {"<ol", "<ul", "<li", "<h1", "<h2", "<h3", "<h4", "<h5", "<h6"}
             if any(tag in original_input for tag in list_heading_tags):
                 leading_newlines = re.match(r"^[\n\r]*", leading_whitespace)
@@ -751,19 +735,14 @@ def convert_to_markdown(
     def normalize_spaces_outside_code(text: str) -> str:
         parts = text.split("```")
         for i in range(0, len(parts), 2):
-            # Process each line separately to preserve leading spaces
             lines = parts[i].split("\n")
             processed_lines = []
             for line in lines:
-                # Preserve definition list formatting (: followed by 3 spaces)
                 def_parts = re.split(r"(:\s{3})", line)
                 for j in range(0, len(def_parts), 2):
-                    # Only normalize non-definition-list parts
-                    # Also preserve leading spaces (for list indentation)
                     match = re.match(r"^(\s*)(.*)", def_parts[j])
                     if match:
                         leading_spaces, rest = match.groups()
-                        # Only normalize multiple spaces that are not at the beginning
                         rest = re.sub(r" {3,}", " ", rest)
                         def_parts[j] = leading_spaces + rest
                 processed_lines.append("".join(def_parts))

{html_to_markdown-1.9.0.dist-info → html_to_markdown-1.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: html-to-markdown
-Version: 1.9.0
+Version: 1.9.1
 Summary: A modern, type-safe Python library for converting HTML to Markdown with comprehensive tag support and customizable options
 Author-email: Na'aman Hirschfeld <nhirschfeld@gmail.com>
 License: MIT
@@ -30,10 +30,10 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: beautifulsoup4>=4.13.4
+Requires-Dist: beautifulsoup4>=4.13.5
 Requires-Dist: nh3>=0.3
 Provides-Extra: lxml
-Requires-Dist: lxml>=6; extra == "lxml"
+Requires-Dist: lxml>=6.0.1; extra == "lxml"
 Dynamic: license-file
 
 # html-to-markdown
@@ -42,6 +42,14 @@ A modern, fully typed Python library for converting HTML to Markdown. This libra
 of [markdownify](https://pypi.org/project/markdownify/) with a modernized codebase, strict type safety and support for
 Python 3.9+.
 
+## Support This Project
+
+If you find html-to-markdown useful, please consider sponsoring the development:
+
+<a href="https://github.com/sponsors/Goldziher"><img src="https://img.shields.io/badge/Sponsor-%E2%9D%A4-pink?logo=github-sponsors" alt="Sponsor on GitHub" height="32"></a>
+
+Your support helps maintain and improve this library for the community! 🚀
+
 ## Features
 
 - **Full HTML5 Support**: Comprehensive support for all modern HTML5 elements including semantic, form, table, ruby, interactive, structural, SVG, and math elements

{html_to_markdown-1.9.0.dist-info → html_to_markdown-1.9.1.dist-info}/RECORD

@@ -2,15 +2,15 @@ html_to_markdown/__init__.py,sha256=TzZzhZDJHeXW_3B9zceYehz2zlttqdLsDr5un8stZLM,
 html_to_markdown/__main__.py,sha256=DJyJX7NIK0BVPNS2r3BYJ0Ci_lKHhgVOpw7ZEqACH3c,323
 html_to_markdown/cli.py,sha256=8xlgSEcnqsSM_dr1TCSgPDAo09YvUtO78PvDFivFFdg,6973
 html_to_markdown/constants.py,sha256=8vqANd-7wYvDzBm1VXZvdIxS4Xom4Ov_Yghg6jvmyio,584
-html_to_markdown/converters.py,sha256=ESOZQSW8qGAG1S9f_iDpPUirKIc9MGz_G0_rqbTCJ30,50018
+html_to_markdown/converters.py,sha256=n0OeRnfDc7sH2j5oOuqJQmxySJxRFdfpPRHcrHJXFGE,46869
 html_to_markdown/exceptions.py,sha256=s1DaG6A23rOurF91e4jryuUzplWcC_JIAuK9_bw_4jQ,1558
 html_to_markdown/preprocessor.py,sha256=S4S1ZfLC_hkJVgmA5atImTyWQDOxfHctPbaep2QtyrQ,11248
-html_to_markdown/processing.py,sha256=iUVZfDG_QmFsY32O3mJZEuyxS2m8cjZaNnsstx2RkQo,40544
+html_to_markdown/processing.py,sha256=ephjzcUJOilId8Z6AScaMY6AKkyNq9N0A1DMt9HfVuk,39068
 html_to_markdown/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 html_to_markdown/utils.py,sha256=QgWPzmpZKFd6wDTe8IY3gbVT3xNzoGV3PBgd17J0O-w,2066
-html_to_markdown-1.9.0.dist-info/licenses/LICENSE,sha256=3J_HR5BWvUM1mlIrlkF32-uC1FM64gy8JfG17LBuheQ,1122
-html_to_markdown-1.9.0.dist-info/METADATA,sha256=Rptd2quL9YEGi7Bmh-pgbdPGx-8Ud8EZeZZLQNIMEik,18450
-html_to_markdown-1.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-html_to_markdown-1.9.0.dist-info/entry_points.txt,sha256=xmFijrTfgYW7lOrZxZGRPciicQHa5KiXKkUhBCmICtQ,116
-html_to_markdown-1.9.0.dist-info/top_level.txt,sha256=Ev6djb1c4dSKr_-n4K-FpEGDkzBigXY6LuZ5onqS7AE,17
-html_to_markdown-1.9.0.dist-info/RECORD,,
+html_to_markdown-1.9.1.dist-info/licenses/LICENSE,sha256=3J_HR5BWvUM1mlIrlkF32-uC1FM64gy8JfG17LBuheQ,1122
+html_to_markdown-1.9.1.dist-info/METADATA,sha256=FUHr7dId_1ZQfgKjPcInKwvwBChyxlyPMIwYl0Z4dko,18813
+html_to_markdown-1.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+html_to_markdown-1.9.1.dist-info/entry_points.txt,sha256=xmFijrTfgYW7lOrZxZGRPciicQHa5KiXKkUhBCmICtQ,116
+html_to_markdown-1.9.1.dist-info/top_level.txt,sha256=Ev6djb1c4dSKr_-n4K-FpEGDkzBigXY6LuZ5onqS7AE,17
+html_to_markdown-1.9.1.dist-info/RECORD,,