convert-md 1.0.0__py3-none-any.whl

convert_md/__init__.py

@@ -0,0 +1,3 @@
+"""convert-md: convert between Markdown and Word, PDF, Excel, PowerPoint and HTML."""
+
+__version__ = "1.0.0"

convert_md/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from convert_md.cli import main
+
+sys.exit(main())

convert_md/cli.py

@@ -0,0 +1,241 @@
+"""Command line for convert-md.
+
+    convert-md --to docx Report.md            convert (also: pdf, xlsx, pptx, html, all, auto)
+    convert-md --to docx,pdf Report.md        several formats
+    convert-md --to md Contract.pdf Deck.pptx anything to Markdown
+    convert-md setup                          add the right-click menus and Ctrl+Alt+M hotkey
+    convert-md remove                         take them away again
+    convert-md doctor                         check the installation
+    convert-md templates                      create starter Word/PowerPoint style templates
+
+`python -m convert_md ...` works the same way.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from convert_md import __version__
+from convert_md.converter import OUT_FORMATS, ConversionError, available_pdf_engines, run
+from convert_md.paths import data_dir, log_path, template_dir
+
+APP_NAME = "convert-md"
+COMMANDS = ("setup", "remove", "doctor", "templates")
+
+
+# --------------------------------------------------------------------------- popup
+
+def show_popup(done: list[Path], errors: list[str]) -> None:
+    lines: list[str] = []
+    if done:
+        lines.append("Created:")
+        lines += [f"   {p.name}" for p in done]
+    if errors:
+        if lines:
+            lines.append("")
+        lines.append("Problems:")
+        lines += [f"   {e}" for e in errors]
+        lines += ["", f"Details in {log_path()}"]
+    message = "\n".join(lines) or "Nothing to do."
+    try:
+        import tkinter as tk
+        from tkinter import messagebox
+        root = tk.Tk()
+    except Exception:  # no Tk, or no display
+        print(message)
+        return
+    root.withdraw()
+    root.attributes("-topmost", True)
+    if errors:
+        messagebox.showwarning(APP_NAME, message, parent=root)
+        root.destroy()
+        return
+    # Success: small window in the corner that closes itself after a few seconds.
+    win = tk.Toplevel(root)
+    win.title(APP_NAME)
+    win.attributes("-topmost", True)
+    win.resizable(False, False)
+    tk.Label(win, text=message, justify="left", padx=18, pady=14, font=("Segoe UI", 10)).pack()
+    tk.Button(win, text="OK", width=10, command=root.destroy).pack(pady=(0, 12))
+    win.protocol("WM_DELETE_WINDOW", root.destroy)
+    win.update_idletasks()
+    x = win.winfo_screenwidth() - win.winfo_width() - 40
+    y = win.winfo_screenheight() - win.winfo_height() - 90
+    win.geometry(f"+{max(x, 0)}+{max(y, 0)}")
+    root.after(4000, root.destroy)
+    root.mainloop()
+
+
+# --------------------------------------------------------------------------- convert
+
+def convert_main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(
+        prog="convert-md", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--version", action="version", version=f"convert-md {__version__}")
+    parser.add_argument("--to", required=True,
+                        help="md, auto, all, or a comma list of: " + ", ".join(OUT_FORMATS))
+    parser.add_argument("--gui", action="store_true", help="show a popup with the result")
+    parser.add_argument("files", nargs="+")
+    args = parser.parse_args(argv)
+
+    try:
+        done, errors = run(args.files, args.to)
+    except ConversionError as exc:
+        done, errors = [], [str(exc)]
+
+    if args.gui:
+        show_popup(done, errors)
+    else:
+        for p in done:
+            print(f"created  {p}")
+        for e in errors:
+            print(f"error    {e}", file=sys.stderr)
+    return 1 if errors else 0
+
+
+# --------------------------------------------------------------------------- commands
+
+def _require_windows(what: str) -> bool:
+    if sys.platform != "win32":
+        print(f"{what} is only available on Windows. Conversions work everywhere: convert-md --to ...")
+        return False
+    return True
+
+
+def cmd_setup(args: argparse.Namespace) -> int:
+    if not _require_windows("setup"):
+        return 1
+    from convert_md import windows
+    pythonw = windows.pythonw_path()
+    print(f"convert-md {__version__}  (Python: {pythonw})")
+    status = 0
+    if not args.no_menus:
+        windows.install_menus(pythonw)
+        print("  right-click menus   installed (under 'Show more options' on Windows 11)")
+    if not args.no_hotkey:
+        if windows.autohotkey_available():
+            script = windows.install_hotkey(pythonw, args.hotkey)
+            print(f"  hotkey              installed and started ({script})")
+        else:
+            print("  hotkey              skipped: AutoHotkey v2 is not installed")
+            print("                      install it with: winget install AutoHotkey.AutoHotkey -e")
+            print("                      then run: convert-md setup")
+            status = 2
+    return status
+
+
+def cmd_remove(args: argparse.Namespace) -> int:
+    if not _require_windows("remove"):
+        return 1
+    from convert_md import windows
+    windows.remove_menus()
+    windows.remove_hotkey()
+    print("convert-md menus and hotkey removed.")
+    print(f"Templates and the log are kept in {data_dir()} (delete the folder if you don't need them).")
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    rows: list[tuple[str, str, bool]] = []
+
+    def check(name: str, ok: bool, detail: str) -> None:
+        rows.append((name, detail, ok))
+
+    check("convert-md", True, __version__)
+    check("Python", sys.version_info >= (3, 11), f"{sys.version.split()[0]}  {sys.executable}")
+    try:
+        import pypandoc
+        check("Pandoc", True, pypandoc.get_pandoc_version())
+    except Exception as exc:
+        check("Pandoc", False, f"not working: {exc}")
+    try:
+        from importlib.metadata import version
+        check("MarkItDown", True, version("markitdown"))
+    except Exception as exc:
+        check("MarkItDown", False, f"not installed: {exc}")
+
+    engines = available_pdf_engines()
+    if sys.platform == "win32":
+        from convert_md import windows
+        word = windows.word_available()
+        check("PDF", word or bool(engines),
+              "Microsoft Word" if word else (f"Pandoc engine: {engines[0]}" if engines
+                                             else "no Word and no PDF engine (winget install Typst.Typst)"))
+        cmd = windows.menu_command()
+        expected = windows.pythonw_path()
+        if cmd is None:
+            check("Right-click menus", False, "not installed (run: convert-md setup)")
+        elif expected.lower() not in cmd.lower():
+            check("Right-click menus", False, f"point at a different Python: {cmd}  (run: convert-md setup)")
+        else:
+            check("Right-click menus", True, "installed")
+        if windows.hotkey_installed():
+            check("Hotkey", True, "installed")
+        elif windows.autohotkey_available():
+            check("Hotkey", False, "not installed (run: convert-md setup)")
+        else:
+            check("Hotkey", False, "AutoHotkey v2 not installed (optional)")
+    else:
+        check("PDF", bool(engines), f"Pandoc engine: {engines[0]}" if engines else "no PDF engine found")
+
+    tdir = template_dir()
+    found = [p.name for p in (tdir / "reference.docx", tdir / "reference.pptx", tdir / "style.css") if p.exists()]
+    check("Templates", True, ", ".join(found) if found else "none (optional; convert-md templates)")
+    check("Log", True, str(log_path()))
+
+    width = max(len(r[0]) for r in rows)
+    for name, detail, ok in rows:
+        print(f"  {'OK ' if ok else '-- '} {name.ljust(width)}  {detail}")
+    essential = {"Python", "Pandoc", "MarkItDown"}
+    return 0 if all(ok for name, _, ok in rows if name in essential) else 1
+
+
+def cmd_templates(args: argparse.Namespace) -> int:
+    import subprocess
+    import pypandoc
+    tdir = template_dir()
+    tdir.mkdir(parents=True, exist_ok=True)
+    for name in ("reference.docx", "reference.pptx"):
+        dest = tdir / name
+        if dest.exists():
+            print(f"  kept      {dest}")
+            continue
+        with open(dest, "wb") as fh:
+            subprocess.run([pypandoc.get_pandoc_path(), "--print-default-data-file", name],
+                           stdout=fh, check=True)
+        print(f"  created   {dest}")
+    print("Open these in Word / PowerPoint and change the styles (not the text).")
+    print("Add style.css in the same folder to style HTML output.")
+    if sys.platform == "win32":
+        import os
+        os.startfile(str(tdir))  # type: ignore[attr-defined]
+    return 0
+
+
+def command_main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(prog="convert-md")
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("setup", help="add the right-click menus and the hotkey")
+    p.add_argument("--no-menus", action="store_true", help="skip the right-click menus")
+    p.add_argument("--no-hotkey", action="store_true", help="skip the AutoHotkey hotkey")
+    p.add_argument("--hotkey", default="^!m",
+                   help="AutoHotkey key combination, default ^!m (Ctrl+Alt+M)")
+    p.set_defaults(func=cmd_setup)
+    sub.add_parser("remove", help="remove the menus and hotkey").set_defaults(func=cmd_remove)
+    sub.add_parser("doctor", help="check the installation").set_defaults(func=cmd_doctor)
+    sub.add_parser("templates", help="create starter style templates").set_defaults(func=cmd_templates)
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    if argv and argv[0] in COMMANDS:
+        return command_main(argv)
+    return convert_main(argv)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

convert_md/convert-md-hotkey.ahk

@@ -0,0 +1,135 @@
+#Requires AutoHotkey v2.0
+#SingleInstance Force
+
+; convert-md hotkey (default Ctrl+Alt+M). Installed by "convert-md setup", which
+; copies this script to %LOCALAPPDATA%\ConvertMd and writes convert-md.ini beside it.
+
+CONFIG := A_ScriptDir "\convert-md.ini"
+PYTHONW := IniRead(CONFIG, "convert-md", "pythonw", "")
+HOTKEY_KEYS := IniRead(CONFIG, "convert-md", "hotkey", "^!m")
+MD_EXTENSIONS := ["md", "markdown"]
+
+if (PYTHONW = "" || !FileExist(PYTHONW)) {
+    MsgBox("convert-md can't find Python.`n`nRun this in PowerShell to repair it:`n    py -m convert_md setup",
+        "convert-md", "Icon!")
+    ExitApp
+}
+
+HotIf(ExplorerOrDesktopActive)
+Hotkey(HOTKEY_KEYS, (*) => ShowConvertMdMenu())
+HotIf()
+
+ExplorerOrDesktopActive(*) {
+    return WinActive("ahk_class CabinetWClass") || WinActive("ahk_class ExploreWClass")
+        || WinActive("ahk_class Progman") || WinActive("ahk_class WorkerW")
+}
+
+ShowConvertMdMenu() {
+    if (WinActive("ahk_class Progman") || WinActive("ahk_class WorkerW")) {
+        Notify("convert-md: the hotkey works in File Explorer windows.`nOn the desktop, right-click the file instead.")
+        return
+    }
+    files := GetSelectedFiles()
+    if (files.Length = 0) {
+        Notify("convert-md: nothing selected")
+        return
+    }
+
+    ; Split the selection: Markdown files go out to other formats,
+    ; everything else comes in to Markdown.
+    mdFiles := []
+    otherFiles := []
+    for file in files {
+        SplitPath(file, , , &ext)
+        if IsMarkdownExt(ext)
+            mdFiles.Push(file)
+        else
+            otherFiles.Push(file)
+    }
+
+    convertMenu := Menu()
+    if (mdFiles.Length > 0) {
+        convertMenu.Add("Word", (*) => RunConvert(mdFiles, "docx"))
+        convertMenu.Add("PDF", (*) => RunConvert(mdFiles, "pdf"))
+        convertMenu.Add("Excel (tables only)", (*) => RunConvert(mdFiles, "xlsx"))
+        convertMenu.Add("PowerPoint", (*) => RunConvert(mdFiles, "pptx"))
+        convertMenu.Add("Web page", (*) => RunConvert(mdFiles, "html"))
+        convertMenu.Add()
+        convertMenu.Add("All formats", (*) => RunConvert(mdFiles, "all"))
+        convertMenu.Add("As set in the file", (*) => RunConvert(mdFiles, "auto"))
+    }
+    if (otherFiles.Length > 0) {
+        if (mdFiles.Length > 0) {
+            convertMenu.Add()
+            convertMenu.Add("Convert the " otherFiles.Length " non-Markdown file(s) to Markdown", (*) => RunConvert(otherFiles, "md"))
+        } else {
+            convertMenu.Add("Convert to Markdown", (*) => RunConvert(otherFiles, "md"))
+        }
+    }
+    convertMenu.Show()
+}
+
+Notify(text) {
+    ToolTip(text)
+    SetTimer(() => ToolTip(), -2000)
+}
+
+IsMarkdownExt(ext) {
+    for mdExt in MD_EXTENSIONS {
+        if (StrLower(ext) = mdExt)
+            return true
+    }
+    return false
+}
+
+; Same command the right-click menu uses. -P keeps the current folder off Python's import path.
+RunConvert(files, toValue) {
+    for file in files
+        Run(Format('"{1}" -P -m convert_md --gui --to {2} "{3}"', PYTHONW, toValue, file))
+}
+
+; Selected files in the active Explorer tab only. Folders are skipped.
+GetSelectedFiles() {
+    paths := []
+    win := GetActiveExplorerTab(WinActive("A"))
+    if !IsObject(win)
+        return paths
+    try {
+        for item in win.Document.SelectedItems() {
+            path := item.Path
+            attrs := FileExist(path)
+            if (attrs != "" && !InStr(attrs, "D"))
+                paths.Push(path)
+        }
+    }
+    return paths
+}
+
+; On Windows 11 every tab in an Explorer window has the same HWND, so match
+; the active tab (ShellTabWindowClass1) against each shell view's own window.
+GetActiveExplorerTab(hwnd) {
+    static IID_IShellBrowser := "{000214E2-0000-0000-C000-000000000046}"
+    activeTab := 0
+    try activeTab := ControlGetHwnd("ShellTabWindowClass1", hwnd)
+    for win in ComObject("Shell.Application").Windows() {
+        try {
+            if (win.HWND != hwnd)
+                continue
+        } catch {
+            continue
+        }
+        if activeTab {
+            thisTab := 0
+            try {
+                shellBrowser := ComObjQuery(win, IID_IShellBrowser, IID_IShellBrowser)
+                ComCall(3, shellBrowser, "uint*", &thisTab)   ; IOleWindow::GetWindow
+            } catch {
+                continue
+            }
+            if (thisTab != activeTab)
+                continue
+        }
+        return win
+    }
+    return 0
+}

convert_md/converter.py

@@ -0,0 +1,367 @@
+"""Conversion engine.
+
+Markdown -> Word, PDF, Excel, PowerPoint, HTML   (Pandoc; Excel is built from the tables)
+Anything -> Markdown                             (Microsoft MarkItDown)
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import re
+import shutil
+import sys
+import tempfile
+import traceback
+from pathlib import Path
+
+from convert_md.paths import log_path, template_dir
+
+OUT_FORMATS = ["docx", "pdf", "xlsx", "pptx", "html"]
+FORMAT_ALIASES = {"word": "docx", "doc": "docx", "excel": "xlsx", "xls": "xlsx",
+                  "powerpoint": "pptx", "ppt": "pptx", "htm": "html"}
+MD_SUFFIXES = {".md", ".markdown", ".mdown", ".mkd"}
+PDF_ENGINES = ["typst", "xelatex", "lualatex", "pdflatex", "weasyprint", "wkhtmltopdf"]
+
+
+class ConversionError(Exception):
+    """A conversion failed for a reason worth showing the user."""
+
+
+# --------------------------------------------------------------------------- logging
+
+def log(message: str) -> None:
+    try:
+        path = log_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        stamp = _dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        with open(path, "a", encoding="utf-8") as fh:
+            fh.write(f"{stamp}  {message}\n")
+    except OSError:
+        pass
+
+
+# --------------------------------------------------------------------------- helpers
+
+def unique_path(path: Path) -> Path:
+    """Return path, or 'name (1).ext', 'name (2).ext'... if it already exists."""
+    if not path.exists():
+        return path
+    n = 1
+    while True:
+        candidate = path.with_name(f"{path.stem} ({n}){path.suffix}")
+        if not candidate.exists():
+            return candidate
+        n += 1
+
+
+def normalise_formats(raw: list[str]) -> list[str]:
+    out: list[str] = []
+    for item in raw:
+        fmt = item.strip().lower().lstrip(".")
+        fmt = FORMAT_ALIASES.get(fmt, fmt)
+        if fmt == "all":
+            for f in OUT_FORMATS:
+                if f not in out:
+                    out.append(f)
+        elif fmt in OUT_FORMATS and fmt not in out:
+            out.append(fmt)
+        elif fmt and fmt not in OUT_FORMATS:
+            raise ConversionError(f"Unknown format '{item}'. Use: {', '.join(OUT_FORMATS)}, all.")
+    return out
+
+
+def auto_formats(md_path: Path, text: str) -> tuple[list[str], str]:
+    """Work out formats from front-matter ('outputs: [docx, pdf]') or the filename
+    ('Report.docx.pdf.md'). Returns (formats, output stem). Defaults to Word."""
+    parts = md_path.stem.split(".")
+    from_name: list[str] = []
+    while len(parts) > 1:
+        candidate = FORMAT_ALIASES.get(parts[-1].lower(), parts[-1].lower())
+        if candidate in OUT_FORMATS or candidate == "all":
+            from_name.insert(0, candidate)
+            parts.pop()
+        else:
+            break
+    clean_stem = ".".join(parts)
+
+    fm = re.match(r"\A---\s*\n(.*?)\n(?:---|\.\.\.)\s*\n", text, re.S)
+    if fm:
+        m = re.search(r"^outputs\s*:\s*(.+)$", fm.group(1), re.M)
+        if m:
+            items = re.split(r"[\s,\[\]]+", m.group(1))
+            formats = normalise_formats([i for i in items if i])
+            if formats:
+                return formats, clean_stem
+    if from_name:
+        return normalise_formats(from_name), clean_stem
+    return ["docx"], clean_stem
+
+
+# --------------------------------------------------------------------------- pandoc
+
+def _pandoc():
+    try:
+        import pypandoc
+    except ImportError as exc:
+        raise ConversionError("pypandoc is not installed. Reinstall convert-md.") from exc
+    return pypandoc
+
+
+def _common_args(src: Path) -> list[str]:
+    return ["--standalone", f"--resource-path={src.parent}"]
+
+
+def to_docx(src: Path, dest: Path) -> Path:
+    args = _common_args(src)
+    ref = template_dir() / "reference.docx"
+    if ref.exists():
+        args.append(f"--reference-doc={ref}")
+    _pandoc().convert_file(str(src), "docx", format="markdown", outputfile=str(dest), extra_args=args)
+    return dest
+
+
+def to_pptx(src: Path, dest: Path) -> Path:
+    args = _common_args(src)
+    ref = template_dir() / "reference.pptx"
+    if ref.exists():
+        args.append(f"--reference-doc={ref}")
+    _pandoc().convert_file(str(src), "pptx", format="markdown", outputfile=str(dest), extra_args=args)
+    return dest
+
+
+def to_html(src: Path, dest: Path) -> Path:
+    args = _common_args(src) + ["--embed-resources", f"--metadata=pagetitle:{dest.stem}"]
+    css = template_dir() / "style.css"
+    if css.exists():
+        args.append(f"--css={css}")
+    _pandoc().convert_file(str(src), "html5", format="markdown", outputfile=str(dest), extra_args=args)
+    return dest
+
+
+# --------------------------------------------------------------------------- pdf
+
+def _word_docx_to_pdf(docx: Path, pdf: Path) -> bool:
+    """Use installed Microsoft Word to save a .docx as PDF. False if Word isn't usable."""
+    if sys.platform != "win32":
+        return False
+    try:
+        import pythoncom
+        import win32com.client
+    except ImportError:
+        return False
+    word = None
+    pythoncom.CoInitialize()
+    try:
+        word = win32com.client.DispatchEx("Word.Application")
+        word.Visible = False
+        word.DisplayAlerts = 0
+        doc = word.Documents.Open(str(docx.resolve()), ReadOnly=True, AddToRecentFiles=False)
+        try:
+            doc.SaveAs2(str(pdf.resolve()), FileFormat=17)  # 17 = wdFormatPDF
+        finally:
+            doc.Close(SaveChanges=0)
+        return pdf.exists()
+    except Exception as exc:  # Word missing, licence prompt, COM error...
+        log(f"Word PDF export failed, falling back to a Pandoc PDF engine: {exc}")
+        return False
+    finally:
+        if word is not None:
+            try:
+                word.Quit()
+            except Exception:
+                pass
+        pythoncom.CoUninitialize()
+
+
+def available_pdf_engines() -> list[str]:
+    return [e for e in PDF_ENGINES if shutil.which(e)]
+
+
+def to_pdf(src: Path, dest: Path, docx_hint: Path | None = None) -> Path:
+    # 1. Microsoft Word: matches the Word output and needs no extra installs.
+    if sys.platform == "win32":
+        with tempfile.TemporaryDirectory() as tmp:
+            docx = docx_hint if docx_hint and docx_hint.exists() else to_docx(src, Path(tmp) / "temp.docx")
+            if _word_docx_to_pdf(docx, dest):
+                return dest
+    # 2. Pandoc with whichever PDF engine is installed.
+    for engine in available_pdf_engines():
+        args = _common_args(src) + [f"--pdf-engine={engine}"]
+        if engine.endswith("latex"):
+            args += ["-V", "geometry:margin=2cm"]
+        _pandoc().convert_file(str(src), "pdf", format="markdown", outputfile=str(dest), extra_args=args)
+        return dest
+    raise ConversionError(
+        "No way to make a PDF was found. Install Microsoft Word, "
+        "or a PDF engine such as Typst: winget install Typst.Typst")
+
+
+# --------------------------------------------------------------------------- excel
+
+_NUM = re.compile(r"^\(?-?[$€£¥]?\s?-?[\d,]*\.?\d+\)?%?$")
+
+
+def cell_value(text: str):
+    """Turn '1,234', '$12.50', '(300)', '45%' into numbers; leave other text alone.
+    Returns (value, number_format or None)."""
+    t = text.strip()
+    if not t or not _NUM.match(t) or not re.search(r"\d", t):
+        return t, None
+    negative = t.startswith("(") and t.endswith(")")
+    pct = t.endswith("%")
+    core = re.sub(r"[()$€£¥%,\s]", "", t)
+    try:
+        num = float(core)
+    except ValueError:
+        return t, None
+    if negative:
+        num = -abs(num)
+    if pct:
+        return num / 100, "0.0%" if "." in core else "0%"
+    if num.is_integer() and "." not in core:
+        return int(num), "#,##0" if "," in t else None
+    return num, "#,##0.00" if "," in t else None
+
+
+def _sheet_title(raw: str, used: set[str]) -> str:
+    title = re.sub(r"[\[\]:*?/\\]", "", raw).strip()[:31] or "Table"
+    base, n = title, 2
+    while title.lower() in used:
+        suffix = f" ({n})"
+        title = base[: 31 - len(suffix)] + suffix
+        n += 1
+    used.add(title.lower())
+    return title
+
+
+def to_xlsx(src: Path, dest: Path) -> Path:
+    from bs4 import BeautifulSoup
+    from openpyxl import Workbook
+    from openpyxl.styles import Alignment, Font, PatternFill
+    from openpyxl.utils import get_column_letter
+
+    html = _pandoc().convert_file(str(src), "html5", format="markdown")
+    soup = BeautifulSoup(html, "html.parser")
+    tables = soup.find_all("table")
+    if not tables:
+        raise ConversionError("No tables found in this Markdown file, so there is nothing to put in Excel.")
+
+    wb = Workbook()
+    wb.remove(wb.active)
+    used: set[str] = set()
+    header_fill = PatternFill("solid", fgColor="DDEBF7")
+
+    for i, table in enumerate(tables, start=1):
+        caption = table.find("caption")
+        heading = table.find_previous(re.compile(r"^h[1-6]$"))
+        name = (caption.get_text(" ", strip=True) if caption else
+                heading.get_text(" ", strip=True) if heading else f"Table {i}")
+        ws = wb.create_sheet(_sheet_title(name, used))
+
+        rows = table.find_all("tr")
+        widths: dict[int, int] = {}
+        first_is_header = False
+        for r, tr in enumerate(rows, start=1):
+            cells = tr.find_all(["th", "td"])
+            is_header = tr.find_parent("thead") is not None or all(c.name == "th" for c in cells)
+            if r == 1:
+                first_is_header = is_header
+            for c, cell in enumerate(cells, start=1):
+                text = cell.get_text(" ", strip=True)
+                value, fmt = (text, None) if is_header else cell_value(text)
+                target = ws.cell(row=r, column=c, value=value)
+                if fmt:
+                    target.number_format = fmt
+                if is_header:
+                    target.font = Font(bold=True)
+                    target.fill = header_fill
+                    target.alignment = Alignment(vertical="center", wrap_text=True)
+                widths[c] = max(widths.get(c, 0), min(len(text), 60))
+        for c, w in widths.items():
+            ws.column_dimensions[get_column_letter(c)].width = max(10, w + 2)
+        if first_is_header:
+            ws.freeze_panes = "A2"
+            ws.auto_filter.ref = ws.dimensions
+
+    wb.save(dest)
+    return dest
+
+
+# --------------------------------------------------------------------------- to markdown
+
+def to_markdown(src: Path) -> Path:
+    from markitdown import MarkItDown
+
+    result = MarkItDown(enable_plugins=False).convert(str(src))
+    text = (result.text_content or "").strip()
+    if not text:
+        raise ConversionError("No text was found. If this is a scanned PDF it needs OCR first.")
+    dest = unique_path(src.with_suffix(".md"))
+    dest.write_text(text + "\n", encoding="utf-8")
+    return dest
+
+
+# --------------------------------------------------------------------------- driver
+
+CONVERTERS = {"docx": to_docx, "pptx": to_pptx, "html": to_html, "xlsx": to_xlsx}
+
+
+def _first_line(exc: Exception) -> str:
+    text = str(exc).strip()
+    return text.splitlines()[0] if text else exc.__class__.__name__
+
+
+def convert_markdown(src: Path, formats: list[str]) -> tuple[list[Path], list[str]]:
+    text = src.read_text(encoding="utf-8", errors="replace")
+    stem = src.stem
+    if formats == ["auto"]:
+        formats, stem = auto_formats(src, text)
+    done: list[Path] = []
+    errors: list[str] = []
+    docx_out: Path | None = None
+    for fmt in sorted(formats, key=OUT_FORMATS.index):  # Word first so PDF can reuse it
+        dest = unique_path(src.with_name(f"{stem}.{fmt}"))
+        try:
+            out = to_pdf(src, dest, docx_hint=docx_out) if fmt == "pdf" else CONVERTERS[fmt](src, dest)
+            if fmt == "docx":
+                docx_out = out
+            done.append(out)
+            log(f"OK   {src} -> {out}")
+        except Exception as exc:
+            errors.append(f"{src.name} → {fmt}: {_first_line(exc)}")
+            log(f"FAIL {src} -> {fmt}: {exc}\n{traceback.format_exc()}")
+    return done, errors
+
+
+def run(paths: list[str], target: str) -> tuple[list[Path], list[str]]:
+    """Convert each path. target is 'md', 'auto', 'all' or a comma list of formats."""
+    done: list[Path] = []
+    errors: list[str] = []
+    target = target.strip().lower()
+    to_md = target in {"md", "markdown"}
+    formats = ["auto"] if target == "auto" else ([] if to_md else normalise_formats(target.split(",")))
+
+    for raw in paths:
+        src = Path(raw)
+        if not src.is_file():
+            errors.append(f"{raw}: file not found")
+            continue
+        try:
+            if to_md:
+                if src.suffix.lower() in MD_SUFFIXES:
+                    errors.append(f"{src.name}: already Markdown")
+                    continue
+                out = to_markdown(src)
+                done.append(out)
+                log(f"OK   {src} -> {out}")
+            else:
+                if src.suffix.lower() not in MD_SUFFIXES:
+                    errors.append(f"{src.name}: not a Markdown file")
+                    continue
+                d, e = convert_markdown(src, formats)
+                done += d
+                errors += e
+        except Exception as exc:
+            errors.append(f"{src.name}: {_first_line(exc)}")
+            log(f"FAIL {src}: {exc}\n{traceback.format_exc()}")
+    return done, errors

convert_md/paths.py

@@ -0,0 +1,29 @@
+"""Where convert-md keeps its per-user files: log, templates, hotkey script and its settings."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+def data_dir() -> Path:
+    """Per-user data folder, e.g. %LOCALAPPDATA%\\ConvertMd on Windows.
+
+    Set CONVERT_MD_HOME to use a different folder.
+    """
+    override = os.environ.get("CONVERT_MD_HOME")
+    if override:
+        return Path(override)
+    if sys.platform == "win32" and os.environ.get("LOCALAPPDATA"):
+        return Path(os.environ["LOCALAPPDATA"]) / "ConvertMd"
+    base = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    return Path(base) / "convert-md"
+
+
+def log_path() -> Path:
+    return data_dir() / "convert-md.log"
+
+
+def template_dir() -> Path:
+    return data_dir() / "templates"

convert_md/windows.py

@@ -0,0 +1,212 @@
+"""Windows integration: right-click menus, Ctrl+Alt+M hotkey, status checks.
+
+Everything is per-user (HKEY_CURRENT_USER and the user's Startup folder), so no
+administrator rights are needed. The menus and hotkey call
+    pythonw.exe -P -m convert_md --gui --to <format> "<file>"
+-P stops Python adding the current folder to the import path, so a file named
+convert_md.py sitting next to the document can't be run in place of convert-md.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+from importlib import resources
+from pathlib import Path
+
+from convert_md.paths import data_dir
+
+ROOT = r"HKEY_CURRENT_USER\Software\Classes\SystemFileAssociations"
+MARKDOWN_EXTS = [".md", ".markdown"]
+TO_MD_EXTS = [".docx", ".pdf", ".xlsx", ".xls", ".pptx", ".html", ".htm", ".csv", ".epub", ".msg"]
+MD_MENU_KEY = "ConvertMd"
+TO_MD_KEY = "ConvertMdToMarkdown"
+
+# (key, label, --to value, separator_before)
+MD_MENU = [
+    ("1_docx", "Word (.docx)", "docx", False),
+    ("2_pdf", "PDF (.pdf)", "pdf", False),
+    ("3_xlsx", "Excel (.xlsx) - tables only", "xlsx", False),
+    ("4_pptx", "PowerPoint (.pptx)", "pptx", False),
+    ("5_html", "Web page (.html)", "html", False),
+    ("6_all", "All formats", "all", True),
+    ("7_auto", "As set in the file", "auto", False),
+]
+
+HOTKEY_SCRIPT = "convert-md-hotkey.ahk"
+HOTKEY_CONFIG = "convert-md.ini"
+SHORTCUT_NAME = "convert-md-hotkey.lnk"
+
+# Names used by pre-1.0 private builds (then called md-convert); setup and remove clean them up.
+LEGACY_MENU_KEYS = ["MdConvert", "MdConvertToMarkdown"]
+LEGACY_SCRIPT = "md-convert-hotkey.ahk"
+LEGACY_SHORTCUT = "md-convert-hotkey.lnk"
+DEFAULT_HOTKEY = "^!m"   # Ctrl+Alt+M in AutoHotkey notation
+
+
+# --------------------------------------------------------------------------- paths
+
+def pythonw_path() -> str:
+    """pythonw.exe next to the running Python (runs without a console window)."""
+    exe = Path(sys.executable)
+    candidate = exe.with_name("pythonw.exe")
+    return str(candidate) if candidate.exists() else str(exe)
+
+
+def startup_dir() -> Path:
+    appdata = os.environ.get("APPDATA", str(Path.home() / "AppData" / "Roaming"))
+    return Path(appdata) / "Microsoft" / "Windows" / "Start Menu" / "Programs" / "Startup"
+
+
+def command_line(pythonw: str, target: str, file_arg: str = "%1") -> str:
+    return f'"{pythonw}" -P -m convert_md --gui --to {target} "{file_arg}"'
+
+
+# --------------------------------------------------------------------------- registry
+
+def _esc(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def registry_files(pythonw: str) -> tuple[str, str]:
+    """Return (install, uninstall) .reg file text for the right-click menus."""
+    lines = ["Windows Registry Editor Version 5.00", "",
+             "; convert-md right-click menus (current user only)", ""]
+    remove = ["Windows Registry Editor Version 5.00", "", "; Removes the convert-md right-click menus", ""]
+
+    legacy = []
+    for ext in MARKDOWN_EXTS + TO_MD_EXTS:
+        legacy += [f"[-{ROOT}\\{ext}\\shell\\{key}]" for key in LEGACY_MENU_KEYS]
+    lines += ["; remove menus left by pre-1.0 builds"] + legacy + [""]
+    remove += legacy + [""]
+
+    for ext in MARKDOWN_EXTS:
+        base = f"{ROOT}\\{ext}\\shell\\{MD_MENU_KEY}"
+        lines += [f"[{base}]", '"MUIVerb"="Convert to"', '"SubCommands"=""', ""]
+        for key, label, target, sep in MD_MENU:
+            lines += [f"[{base}\\shell\\{key}]", f'"MUIVerb"="{_esc(label)}"']
+            if sep:
+                lines.append('"CommandFlags"=dword:00000020')
+            lines += ["", f"[{base}\\shell\\{key}\\command]", f'@="{_esc(command_line(pythonw, target))}"', ""]
+        remove += [f"[-{base}]", ""]
+
+    for ext in TO_MD_EXTS:
+        base = f"{ROOT}\\{ext}\\shell\\{TO_MD_KEY}"
+        lines += [f"[{base}]", '"MUIVerb"="Convert to Markdown"', "",
+                  f"[{base}\\command]", f'@="{_esc(command_line(pythonw, "md"))}"', ""]
+        remove += [f"[-{base}]", ""]
+
+    return "\r\n".join(lines), "\r\n".join(remove)
+
+
+def _reg_import(text: str) -> None:
+    fd, name = tempfile.mkstemp(suffix=".reg")
+    os.close(fd)
+    try:
+        Path(name).write_text(text, encoding="utf-16")  # regedit expects UTF-16 with BOM
+        subprocess.run(["reg", "import", name], check=True, capture_output=True)
+    finally:
+        os.unlink(name)
+
+
+def install_menus(pythonw: str | None = None) -> None:
+    _reg_import(registry_files(pythonw or pythonw_path())[0])
+
+
+def remove_menus() -> None:
+    _reg_import(registry_files(pythonw_path())[1])
+
+
+def menu_command() -> str | None:
+    """The command the 'Convert to → Word' entry currently runs, or None if not installed."""
+    import winreg
+    key = rf"Software\Classes\SystemFileAssociations\.md\shell\{MD_MENU_KEY}\shell\1_docx\command"
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key) as k:
+            return winreg.QueryValueEx(k, "")[0]
+    except OSError:
+        return None
+
+
+# --------------------------------------------------------------------------- hotkey
+
+def autohotkey_available() -> bool:
+    """True if .ahk files are associated with a program (AutoHotkey is installed)."""
+    import winreg
+    for root in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):
+        try:
+            with winreg.OpenKey(root, r"Software\Classes\.ahk"):
+                return True
+        except OSError:
+            continue
+    return False
+
+
+def hotkey_config(pythonw: str, hotkey: str) -> str:
+    return f"[convert-md]\r\npythonw={pythonw}\r\nhotkey={hotkey}\r\n"
+
+
+def stop_hotkey() -> None:
+    """End any running copy of the hotkey script (current or pre-1.0), wherever it was started from."""
+    ps = ("Get-CimInstance Win32_Process -Filter \"Name LIKE 'AutoHotkey%'\" | "
+          f"Where-Object {{ $_.CommandLine -like '*{HOTKEY_SCRIPT}*' -or $_.CommandLine -like '*{LEGACY_SCRIPT}*' }} | "
+          "Invoke-CimMethod -MethodName Terminate | Out-Null")
+    subprocess.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", ps],
+                   capture_output=True, check=False)
+
+
+def _create_shortcut(link: Path, target: Path) -> None:
+    import win32com.client
+    shell = win32com.client.Dispatch("WScript.Shell")
+    sc = shell.CreateShortcut(str(link))
+    sc.TargetPath = str(target)
+    sc.WorkingDirectory = str(target.parent)
+    sc.Description = "convert-md hotkey"
+    sc.Save()
+
+
+def install_hotkey(pythonw: str | None = None, hotkey: str = DEFAULT_HOTKEY) -> Path:
+    """Copy the hotkey script to the data folder, write its settings, add it to Startup and start it."""
+    folder = data_dir()
+    folder.mkdir(parents=True, exist_ok=True)
+    script = folder / HOTKEY_SCRIPT
+    script.write_bytes(resources.files("convert_md").joinpath(HOTKEY_SCRIPT).read_bytes())
+    (folder / HOTKEY_CONFIG).write_text(hotkey_config(pythonw or pythonw_path(), hotkey), encoding="utf-16")
+    stop_hotkey()
+    startup = startup_dir()
+    startup.mkdir(parents=True, exist_ok=True)
+    _unlink(startup / LEGACY_SHORTCUT)
+    _create_shortcut(startup / SHORTCUT_NAME, script)
+    os.startfile(str(script))  # type: ignore[attr-defined]
+    return script
+
+
+def _unlink(path: Path) -> None:
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def remove_hotkey() -> None:
+    stop_hotkey()
+    for path in (startup_dir() / SHORTCUT_NAME, startup_dir() / LEGACY_SHORTCUT,
+                 data_dir() / HOTKEY_SCRIPT, data_dir() / HOTKEY_CONFIG):
+        _unlink(path)
+
+
+def hotkey_installed() -> bool:
+    return (startup_dir() / SHORTCUT_NAME).exists() and (data_dir() / HOTKEY_SCRIPT).exists()
+
+
+# --------------------------------------------------------------------------- word
+
+def word_available() -> bool:
+    import winreg
+    try:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"Word.Application\CLSID"):
+            return True
+    except OSError:
+        return False

convert_md-1.0.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: convert-md
+Version: 1.0.0
+Summary: Right-click conversion between Markdown and Word, PDF, Excel, PowerPoint and HTML on Windows, using Pandoc and Microsoft MarkItDown.
+Author: W3i
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/W3i-io/convert-md
+Project-URL: Documentation, https://github.com/W3i-io/convert-md/blob/main/DEPLOY.md
+Project-URL: Issues, https://github.com/W3i-io/convert-md/issues
+Project-URL: Changelog, https://github.com/W3i-io/convert-md/blob/main/CHANGELOG.md
+Keywords: markdown,pandoc,markitdown,docx,pdf,xlsx,pptx,windows,context-menu,converter
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: markitdown[docx,outlook,pdf,pptx,xls,xlsx]<0.2,>=0.1.7
+Requires-Dist: pypandoc_binary>=1.17
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: pywin32>=306; sys_platform == "win32"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# convert-md
+
+Right-click conversion between Markdown and Word, PDF, Excel, PowerPoint and HTML on Windows,
+built on [Pandoc](https://pandoc.org) and Microsoft [MarkItDown](https://github.com/microsoft/markitdown).
+
+[![Tests](https://github.com/W3i-io/convert-md/actions/workflows/tests.yml/badge.svg)](https://github.com/W3i-io/convert-md/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/W3i-io/convert-md/blob/main/LICENSE)
+
+## What it does
+
+| Right-click on | Menu | Produces |
+|---|---|---|
+| `.md`, `.markdown` | **Convert to → Word** | `.docx` |
+| | **Convert to → PDF** | `.pdf` (through Microsoft Word, or a Pandoc PDF engine) |
+| | **Convert to → Excel** | `.xlsx`, one sheet per table |
+| | **Convert to → PowerPoint** | `.pptx`, one slide per heading |
+| | **Convert to → Web page** | self-contained `.html` |
+| | **Convert to → All formats** | all of the above |
+| | **Convert to → As set in the file** | the formats the file asks for (see below) |
+| `.docx .pdf .xlsx .xls .pptx .html .htm .csv .epub .msg` | **Convert to Markdown** | `.md` |
+
+![The Convert to submenu on a Markdown file](https://raw.githubusercontent.com/W3i-io/convert-md/main/docs/images/menu-convert-to.png)
+
+![Convert to Markdown on a PowerPoint file](https://raw.githubusercontent.com/W3i-io/convert-md/main/docs/images/menu-to-markdown.png)
+
+- Output is saved next to the original. Nothing is overwritten: a repeat run writes `Report (1).docx`.
+- A small popup confirms what was created and lists any problems.
+- Optional **Ctrl+Alt+M** hotkey: select files in File Explorer and press it to get the same menu at the
+  mouse pointer. Mixed selections work: Markdown files go out, everything else comes in.
+
+| Ctrl+Alt+M on a Markdown file | Ctrl+Alt+M on any other file |
+|---|---|
+| ![Hotkey menu for a Markdown file](https://raw.githubusercontent.com/W3i-io/convert-md/main/docs/images/hotkey-menu.png) | ![Hotkey menu for another file](https://raw.githubusercontent.com/W3i-io/convert-md/main/docs/images/hotkey-to-markdown.png) |
+
+## Install
+
+Needs Windows 10 or 11 and Python 3.11 or newer from python.org
+(`winget install --id Python.Python.3.12 -e --scope user`).
+
+1. Download the latest release from the [Releases page](https://github.com/W3i-io/convert-md/releases)
+   (**Source code (zip)**) and extract it, or `git clone https://github.com/W3i-io/convert-md`.
+2. In PowerShell, in that folder:
+
+   ```powershell
+   powershell -ExecutionPolicy Bypass -File .\install.ps1
+   ```
+
+The installer sets everything up for your Windows account only (no administrator rights), offers to
+install [AutoHotkey v2](https://www.autohotkey.com) for the hotkey, and runs a test conversion.
+Use `-NoHotkey` for the right-click menus only.
+
+Prefer pip? Once it's published to PyPI:
+
+```powershell
+py -m pip install convert-md
+py -m convert_md setup
+```
+
+Updating, moving, uninstalling and troubleshooting: see [DEPLOY.md](https://github.com/W3i-io/convert-md/blob/main/DEPLOY.md).
+
+On Windows 11 the menu entries are under **Show more options**, Shift + right-click, or Shift + F10.
+
+## Choosing formats inside the file
+
+**Convert to → As set in the file** reads `outputs:` from the front-matter first, then the filename,
+and otherwise makes a Word document.
+
+```markdown
+---
+outputs: [docx, pdf, xlsx]
+---
+```
+
+Or name the file `Proposal.docx.pdf.md` to get `Proposal.docx` and `Proposal.pdf`.
+
+## House styling
+
+```powershell
+convert-md templates
+```
+
+creates starter `reference.docx` and `reference.pptx` in `%LOCALAPPDATA%\ConvertMd\templates` and opens the
+folder. Change their **styles** (fonts, heading colours, margins, slide masters) in Word or PowerPoint,
+not their text. From then on every conversion uses them, and Word-made PDFs follow the Word styles.
+Add a `style.css` in the same folder to style HTML output.
+
+## Command line
+
+```powershell
+convert-md --to docx Report.md
+convert-md --to docx,pdf,xlsx Report.md
+convert-md --to all Report.md
+convert-md --to md Contract.pdf Deck.pptx
+convert-md doctor          # check the installation
+```
+
+If `convert-md` isn't found, use `py -m convert_md` instead: pip may have put the command in a folder
+that isn't on your PATH.
+
+## Known limitations
+
+| Area | Limitation |
+|---|---|
+| Platform | The menus and hotkey are Windows only. The command line also works on macOS and Linux. |
+| Windows 11 menu | Entries appear under **Show more options**, not in the compact top-level menu. |
+| Excel output | Only tables are exported. Text, lists and images outside tables are left out; there are no formulas. |
+| PDF output | Needs Microsoft Word, or a PDF engine such as Typst (`winget install Typst.Typst`). Engine-made PDFs look different from Word-made ones. |
+| PowerPoint output | One slide per heading with Pandoc's default layout; long sections overflow the slide. Use `reference.pptx` for your own master. |
+| Scanned PDFs | Image-only PDFs have no text to extract; run OCR on them first. |
+| Conversion quality | Complex layouts (multi-column PDFs, merged table cells, text boxes, charts) come through partially or as plain text. |
+| Protected files | Password-protected or rights-managed documents can't be converted. |
+| Legacy formats | Old `.doc` and `.ppt` files aren't supported; save them as `.docx` / `.pptx` first. |
+| Several files at once | Windows starts one conversion per file from the right-click menu, so each shows its own popup. |
+| Hotkey | Needs AutoHotkey v2. Works in File Explorer windows only: not on the desktop, in Open/Save dialogs or in other file managers. |
+| Output folder | Files are written next to the original, so read-only folders fail. |
+| Remote images | Images linked by URL in Markdown are downloaded by Pandoc when embedded. |
+
+## Privacy and security
+
+Conversions run entirely on your PC; convert-md sends nothing anywhere. It changes the registry only
+under your own account (`HKEY_CURRENT_USER`). See [SECURITY.md](https://github.com/W3i-io/convert-md/blob/main/SECURITY.md)
+for details and how to report a vulnerability.
+
+## Credits and licence
+
+convert-md is MIT licensed. It relies on [Pandoc](https://pandoc.org) (GPL, installed separately through
+`pypandoc_binary`), [MarkItDown](https://github.com/microsoft/markitdown) (MIT),
+[openpyxl](https://openpyxl.readthedocs.io), [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/),
+[pywin32](https://github.com/mhammond/pywin32) and, for the hotkey, [AutoHotkey](https://www.autohotkey.com) (GPL).

convert_md-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+convert_md/__init__.py,sha256=dIgGLWeROkKA6G0KoVBpUfnVBxuN64voZ6KdH05qh9A,109
+convert_md/__main__.py,sha256=laSwHYVcldLEEypQ4W4Whrmum7IwNiS9pIazZeW9PTs,62
+convert_md/cli.py,sha256=gY46nk8WjkLPLQ1xRvQQNwupGDLNkL1R3U4zGH9Lla0,9670
+convert_md/convert-md-hotkey.ahk,sha256=Qiwnazvjg4qabfPOF_rxAxGmlNdJVvsWD7E5OhNd5Dw,4408
+convert_md/converter.py,sha256=8q1ALy5bZQAnFKJzqosKTCFx_Xioa8-Ujb71kk_YQtM,13337
+convert_md/paths.py,sha256=eypdp4-P6ysmRFxLMhNGwj70PmwSSTPRRZZHCK_NPe0,817
+convert_md/windows.py,sha256=5hAHDScSba0SbuqJcaR2AT4p3_VzWm52qmKZ_rM6tss,7933
+convert_md-1.0.0.dist-info/licenses/LICENSE,sha256=j5K6dbni-Mkk6z_hezrGL6IcG-EPcz4ESgktMUcxirc,1060
+convert_md-1.0.0.dist-info/METADATA,sha256=kLjgt0akbMrD6wMUIBotqGAgxnbY_eOf0N5DnxuZ_Gc,8130
+convert_md-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+convert_md-1.0.0.dist-info/entry_points.txt,sha256=19Le5IDvbEVIvTbC9hUK_TvPWDikc-OfJP_KJGbGD8o,51
+convert_md-1.0.0.dist-info/top_level.txt,sha256=eU0BYkPE_CaW9i8QdDte9OXsCGea6RG79taYcy2skAk,11
+convert_md-1.0.0.dist-info/RECORD,,

convert_md-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

convert_md-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+convert-md = convert_md.cli:main

convert_md-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 W3i
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

convert_md-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+convert_md