md2linkedin 0.1.0__tar.gz

md2linkedin-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 md2linkedin authors
+
+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.

md2linkedin-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: md2linkedin
+Version: 0.1.0
+Summary: Convert Markdown to LinkedIn-friendly Unicode text
+Keywords: markdown,linkedin,unicode,formatting,conversion
+Author: Indrajeet Patil
+Author-email: Indrajeet Patil <patilindrajeet.science@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Requires-Dist: click>=8.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/IndrajeetPatil/md2linkedin
+Project-URL: Documentation, https://www.indrapatil.com/md2linkedin/
+Project-URL: Repository, https://github.com/IndrajeetPatil/md2linkedin
+Project-URL: Issues, https://github.com/IndrajeetPatil/md2linkedin/issues
+Project-URL: Changelog, https://github.com/IndrajeetPatil/md2linkedin/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+
+
+
+# md2linkedin <img src="docs/assets/logo.png" align="right" width="240" />
+
+[![PyPI
+version](https://img.shields.io/pypi/v/md2linkedin.png)](https://pypi.org/project/md2linkedin/)
+![Python versions](https://img.shields.io/pypi/pyversions/md2linkedin.png)
+[![PyPI
+Downloads](https://img.shields.io/pypi/dm/md2linkedin.png)](https://pypistats.org/packages/md2linkedin)
+
+`md2linkedin` converts Markdown text to LinkedIn-compatible plain text by
+replacing bold, italic, and bold-italic markers with Unicode Mathematical
+Sans-Serif characters. This preserves visual formatting when pasting into
+platforms like LinkedIn that do not support Markdown natively.
+
+## Installation
+
+| Package Manager | Installation Command      |
+|-----------------|---------------------------|
+| pip             | `pip install md2linkedin` |
+| uv              | `uv add md2linkedin`      |
+
+## Usage
+
+### Python API
+
+``` python
+from md2linkedin import convert
+
+md = """
+# Exciting News
+
+I'm thrilled to share that **we just launched** a new product!
+
+Key highlights:
+
+- **Performance**: *3x faster* than the previous version
+- **Reliability**: ***zero downtime*** deployments
+- **Developer UX**: clean, intuitive API
+
+Check it out and let me know what you think.
+"""
+
+print(convert(md))
+```
+
+    
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    𝗘𝗫𝗖𝗜𝗧𝗜𝗡𝗚 𝗡𝗘𝗪𝗦
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    
+    𝘐'𝘮 𝘵𝘩𝘳𝘪𝘭𝘭𝘦𝘥 𝘵𝘰 𝘴𝘩𝘢𝘳𝘦 𝘵𝘩𝘢𝘵 𝗿𝗲 𝗷𝘂𝘀𝘁 𝗹𝗮𝘂𝗻𝗰𝗵𝗲𝗱 a new product!
+    
+    Key highlights:
+    
+    • 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: 𝘴𝘱𝘦𝘦𝘥 is faster than the previous version
+    • 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝙯𝙚𝙧𝙤 𝙙𝙤𝙬𝙣𝙩𝙞𝙢𝙚 deployments
+    • 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗨𝗫: clean, intuitive API
+    
+    Check it out and let me know what you think.
+
+### CLI
+
+``` bash
+# Convert a Markdown file (output: post.linkedin.txt)
+md2linkedin post.md
+
+# Specify output path
+md2linkedin post.md -o linkedin_post.txt
+
+# Pipe from stdin
+echo "**Hello**, *world*!" | md2linkedin
+
+# Keep link URLs in the output
+md2linkedin post.md --preserve-links
+```
+
+## Key Features
+
+- **Bold**: `**text**` or `__text__` → Unicode Sans-Serif Bold (𝗯𝗼𝗹𝗱)
+- **Italic**: `*text*` or `_text_` → Unicode Sans-Serif Italic (𝘪𝘵𝘢𝘭𝘪𝘤)
+- **Bold-italic**: `***text***` or `___text___` → Unicode Sans-Serif Bold
+  Italic (𝙗𝙤𝙡𝙙-𝙞𝙩𝙖𝙡𝙞𝙘)
+- **Headers**: `#`/`##`/etc. styled with bold Unicode; H1 gets a `━` border
+- **Code spans**: backticks stripped, content kept as plain text — *never*
+  Unicode-transformed
+- **Fenced code blocks**: preserved verbatim
+- **Links**: stripped to display text by default; `--preserve-links` retains
+  URLs
+- **Images**: replaced by alt text
+- **Bullet lists**: `-`/`*`/`+` → `•`; nested items → `‣`
+- **Blockquotes**: leading `>` stripped
+- **HTML spans**: unwrapped, inner text preserved
+- **HTML entities**: decoded (`&amp;` → `&`, etc.)
+- **Backslash escapes**: resolved (`\*` → `*`)
+- **Windows line endings**: normalised automatically
+- **Emojis & non-ASCII**: pass through unchanged — no accidental corruption
+
+For more examples, check out the package documentation at:
+<https://www.indrapatil.com/md2linkedin/>
+
+## License
+
+This project is licensed under the MIT License.
+
+## Code of Conduct
+
+Please note that the md2linkedin project is released with a [Contributor
+Code of
+Conduct](https://www.contributor-covenant.org/version/3/0/code_of_conduct/).
+By contributing to this project, you agree to abide by its terms.
+
+## Acknowledgements
+
+Hex sticker font is `Rubik`. Icons are sourced from
+[Flaticon](https://www.flaticon.com/):
+
+- Markdown icon by [Freepik](https://www.flaticon.com/authors/freepik)
+- LinkedIn icon by [Freepik](https://www.flaticon.com/authors/freepik)
+- Arrow/conversion icon by
+  [Freepik](https://www.flaticon.com/authors/freepik)

md2linkedin-0.1.0/README.md

@@ -0,0 +1,122 @@
+
+
+
+# md2linkedin <img src="docs/assets/logo.png" align="right" width="240" />
+
+[![PyPI
+version](https://img.shields.io/pypi/v/md2linkedin.png)](https://pypi.org/project/md2linkedin/)
+![Python versions](https://img.shields.io/pypi/pyversions/md2linkedin.png)
+[![PyPI
+Downloads](https://img.shields.io/pypi/dm/md2linkedin.png)](https://pypistats.org/packages/md2linkedin)
+
+`md2linkedin` converts Markdown text to LinkedIn-compatible plain text by
+replacing bold, italic, and bold-italic markers with Unicode Mathematical
+Sans-Serif characters. This preserves visual formatting when pasting into
+platforms like LinkedIn that do not support Markdown natively.
+
+## Installation
+
+| Package Manager | Installation Command      |
+|-----------------|---------------------------|
+| pip             | `pip install md2linkedin` |
+| uv              | `uv add md2linkedin`      |
+
+## Usage
+
+### Python API
+
+``` python
+from md2linkedin import convert
+
+md = """
+# Exciting News
+
+I'm thrilled to share that **we just launched** a new product!
+
+Key highlights:
+
+- **Performance**: *3x faster* than the previous version
+- **Reliability**: ***zero downtime*** deployments
+- **Developer UX**: clean, intuitive API
+
+Check it out and let me know what you think.
+"""
+
+print(convert(md))
+```
+
+    
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    𝗘𝗫𝗖𝗜𝗧𝗜𝗡𝗚 𝗡𝗘𝗪𝗦
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    
+    𝘐'𝘮 𝘵𝘩𝘳𝘪𝘭𝘭𝘦𝘥 𝘵𝘰 𝘴𝘩𝘢𝘳𝘦 𝘵𝘩𝘢𝘵 𝗿𝗲 𝗷𝘂𝘀𝘁 𝗹𝗮𝘂𝗻𝗰𝗵𝗲𝗱 a new product!
+    
+    Key highlights:
+    
+    • 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: 𝘴𝘱𝘦𝘦𝘥 is faster than the previous version
+    • 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆: 𝙯𝙚𝙧𝙤 𝙙𝙤𝙬𝙣𝙩𝙞𝙢𝙚 deployments
+    • 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗨𝗫: clean, intuitive API
+    
+    Check it out and let me know what you think.
+
+### CLI
+
+``` bash
+# Convert a Markdown file (output: post.linkedin.txt)
+md2linkedin post.md
+
+# Specify output path
+md2linkedin post.md -o linkedin_post.txt
+
+# Pipe from stdin
+echo "**Hello**, *world*!" | md2linkedin
+
+# Keep link URLs in the output
+md2linkedin post.md --preserve-links
+```
+
+## Key Features
+
+- **Bold**: `**text**` or `__text__` → Unicode Sans-Serif Bold (𝗯𝗼𝗹𝗱)
+- **Italic**: `*text*` or `_text_` → Unicode Sans-Serif Italic (𝘪𝘵𝘢𝘭𝘪𝘤)
+- **Bold-italic**: `***text***` or `___text___` → Unicode Sans-Serif Bold
+  Italic (𝙗𝙤𝙡𝙙-𝙞𝙩𝙖𝙡𝙞𝙘)
+- **Headers**: `#`/`##`/etc. styled with bold Unicode; H1 gets a `━` border
+- **Code spans**: backticks stripped, content kept as plain text — *never*
+  Unicode-transformed
+- **Fenced code blocks**: preserved verbatim
+- **Links**: stripped to display text by default; `--preserve-links` retains
+  URLs
+- **Images**: replaced by alt text
+- **Bullet lists**: `-`/`*`/`+` → `•`; nested items → `‣`
+- **Blockquotes**: leading `>` stripped
+- **HTML spans**: unwrapped, inner text preserved
+- **HTML entities**: decoded (`&amp;` → `&`, etc.)
+- **Backslash escapes**: resolved (`\*` → `*`)
+- **Windows line endings**: normalised automatically
+- **Emojis & non-ASCII**: pass through unchanged — no accidental corruption
+
+For more examples, check out the package documentation at:
+<https://www.indrapatil.com/md2linkedin/>
+
+## License
+
+This project is licensed under the MIT License.
+
+## Code of Conduct
+
+Please note that the md2linkedin project is released with a [Contributor
+Code of
+Conduct](https://www.contributor-covenant.org/version/3/0/code_of_conduct/).
+By contributing to this project, you agree to abide by its terms.
+
+## Acknowledgements
+
+Hex sticker font is `Rubik`. Icons are sourced from
+[Flaticon](https://www.flaticon.com/):
+
+- Markdown icon by [Freepik](https://www.flaticon.com/authors/freepik)
+- LinkedIn icon by [Freepik](https://www.flaticon.com/authors/freepik)
+- Arrow/conversion icon by
+  [Freepik](https://www.flaticon.com/authors/freepik)

md2linkedin-0.1.0/pyproject.toml

@@ -0,0 +1,142 @@
+[project]
+name = "md2linkedin"
+version = "0.1.0"
+description = "Convert Markdown to LinkedIn-friendly Unicode text"
+readme = "README.md"
+authors = [
+    { name = "Indrajeet Patil", email = "patilindrajeet.science@gmail.com" }
+]
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE.md"]
+keywords = ["markdown", "linkedin", "unicode", "formatting", "conversion"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Utilities",
+]
+dependencies = ["click>=8.0"]
+
+[project.scripts]
+md2linkedin = "md2linkedin._cli:main"
+
+[project.urls]
+Homepage = "https://github.com/IndrajeetPatil/md2linkedin"
+Documentation = "https://www.indrapatil.com/md2linkedin/"
+Repository = "https://github.com/IndrajeetPatil/md2linkedin"
+Issues = "https://github.com/IndrajeetPatil/md2linkedin/issues"
+Changelog = "https://github.com/IndrajeetPatil/md2linkedin/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+dev = [
+    "coverage>=7.13.5",
+    "jupyter>=1.1.1",
+    "zensical>=0.0.31",
+    "mkdocstrings-python>=2.0.3",
+    "ty>=0.0.28",
+    "prek>=0.3.8",
+    "pytest>=9.0.2",
+    "pytest-cov>=7.1.0",
+    "pytest-random-order>=1.2.0",
+    "ruff>=0.15.9",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12"]
+build-backend = "uv_build"
+
+[tool.ruff]
+fix = true
+preview = true
+unsafe-fixes = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "COM812",
+    "CPY",
+    # Docstring content rules — we intentionally omit Returns/Raises sections
+    # in internal helpers, consistent with ignoring D (pydocstyle) above.
+    "D",
+    "DOC",
+    # This package's output IS Unicode Mathematical characters; having them in
+    # docstring examples and block-comment separators is intentional.
+    "RUF002",
+    "RUF003",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = [
+    # docstring requirements
+    "D",
+    "DOC",
+    # tests can use asserts
+    "S101",
+    # pytest fixtures (e.g. tmp_path) don't need type annotations
+    "ANN001",
+    # tests legitimately import private internals to test them directly
+    "PLC2701",
+    # test methods inside classes don't need @staticmethod — class grouping is intentional
+    "PLR6301",
+    # test assertions for Unicode output use the literal Unicode chars (intentional)
+    "RUF001",
+    # `== ""` vs `not x` — both forms are acceptable in assertions
+    "PLC1901",
+    # magic numbers in assertions are fine (e.g. expected count == 3)
+    "PLR2004",
+    # large test classes are fine when grouping related cases
+    "PLR0904",
+]
+
+[tool.ruff.format]
+preview = true
+docstring-code-format = true
+
+[tool.pytest.ini_options]
+addopts = [
+    # error on problems parsing pytest configuration
+    "--strict-config",
+    # error on using unregistered marker
+    "--strict-markers",
+    # show extra test summary info for everything
+    "-ra",
+    # include more verbose output
+    "--verbose",
+    # using pytest-random-order plugin option
+    "--random-order",
+]
+testpaths = ["tests"]
+filterwarnings = ["error"]
+xfail_strict = true
+python_files = ["test_*.py", "test-*.py", "tests.py", "test.py"]
+
+[tool.coverage.run]
+branch = true
+source = ["md2linkedin"]
+
+[tool.coverage.report]
+fail_under = 100
+format = "markdown"
+sort = "-Cover"
+show_missing = true
+skip_empty = true
+
+[tool.ty.src]
+exclude = [".venv", "build", "dist", "docs"]
+
+[tool.ty.environment]
+python-version = "3.10"
+
+[tool.uv]
+required-version = ">=0.11.2"

md2linkedin-0.1.0/src/md2linkedin/__init__.py

@@ -0,0 +1,31 @@
+"""md2linkedin — Convert Markdown to LinkedIn-friendly Unicode text.
+
+The package exposes two main entry points:
+
+* :func:`convert` — convert a Markdown *string* in memory.
+* :func:`convert_file` — read a ``.md`` file, convert it, and write a
+  ``.linkedin.txt`` output file.
+
+Lower-level Unicode mapping utilities (:func:`to_sans_bold`,
+:func:`to_sans_italic`, :func:`to_sans_bold_italic`, :func:`apply_style`)
+are also public for programmatic use.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from ._converter import convert, convert_file
+from ._unicode import apply_style, to_sans_bold, to_sans_bold_italic, to_sans_italic
+
+__version__ = version("md2linkedin")
+
+__all__ = [
+    "__version__",
+    "apply_style",
+    "convert",
+    "convert_file",
+    "to_sans_bold",
+    "to_sans_bold_italic",
+    "to_sans_italic",
+]

md2linkedin-0.1.0/src/md2linkedin/_cli.py

@@ -0,0 +1,91 @@
+"""Command-line interface for md2linkedin."""
+
+from __future__ import annotations
+
+import sys
+
+import click
+
+from . import __version__
+from ._converter import convert, convert_file
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(__version__, "-V", "--version")
+@click.argument(
+    "input_file",
+    required=False,
+    type=click.Path(exists=True, dir_okay=False),
+)
+@click.option(
+    "-o",
+    "--output",
+    "output_file",
+    default=None,
+    type=click.Path(dir_okay=False),
+    help=(
+        "Output file path. Defaults to INPUT_FILE with a '.linkedin.txt' extension. "
+        "Ignored when reading from stdin."
+    ),
+)
+@click.option(
+    "--preserve-links",
+    is_flag=True,
+    default=False,
+    help=(
+        "Keep Markdown link syntax ([text](url)) in the output"
+        " instead of stripping URLs."
+    ),
+)
+def main(
+    input_file: str | None,
+    output_file: str | None,
+    *,
+    preserve_links: bool,
+) -> None:
+    """Convert Markdown to LinkedIn-friendly Unicode text.
+
+    Reads from INPUT_FILE (or stdin when INPUT_FILE is omitted) and writes
+    LinkedIn-compatible plain text in which bold and italic formatting is
+    preserved using Unicode Mathematical Sans-Serif characters.
+
+    \b
+    Examples:
+
+      # Convert a file (output written to README.linkedin.txt)
+      md2linkedin README.md
+
+      # Specify the output path explicitly
+      md2linkedin README.md -o post.txt
+
+      # Pipe from stdin
+      echo "**Hello**, *world*!" | md2linkedin
+
+      # Keep link URLs in the output
+      md2linkedin README.md --preserve-links
+    """
+    if input_file is not None:
+        out_path = convert_file(input_file, output_file, preserve_links=preserve_links)
+        click.echo(f"LinkedIn-formatted text written to: {out_path}")
+    else:
+        # Read from stdin
+        if _stdin_is_tty():
+            msg = (
+                "No input file provided and stdin is a terminal. "
+                "Provide a file path or pipe content via stdin."
+            )
+            raise click.UsageError(
+                msg
+            )
+        md_text = sys.stdin.read()
+        result = convert(md_text, preserve_links=preserve_links)
+        click.echo(result, nl=False)
+
+
+def _stdin_is_tty() -> bool:
+    """Return True when stdin is an interactive terminal.
+
+    Extracted into its own function so tests can mock it cleanly without
+    fighting Click's own stdin-swapping inside ``CliRunner.invoke``.
+    """
+    return sys.stdin.isatty()

md2linkedin-0.1.0/src/md2linkedin/_converter.py

@@ -0,0 +1,466 @@
+"""Markdown-to-LinkedIn conversion pipeline.
+
+Each step is a small, independently testable function. The top-level
+:func:`convert` function wires them together in the correct order to avoid
+regex conflicts (e.g. bold-italic must be processed before bold or italic).
+"""
+
+from __future__ import annotations
+
+import re
+import uuid
+from pathlib import Path
+
+from ._unicode import to_sans_bold, to_sans_bold_italic, to_sans_italic
+
+__all__ = ["convert", "convert_file"]
+
+_NESTED_BULLET_MIN_INDENT = 2  # spaces of indentation that triggers a nested bullet (‣)
+
+# ── Low-level pipeline steps ───────────────────────────────────────────────────
+
+
+def _normalize_line_endings(text: str) -> str:
+    """Normalize Windows (\\r\\n) and classic Mac (\\r) line endings to \\n."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _protect_code(text: str) -> tuple[str, dict[str, str]]:
+    """Replace code spans and fenced blocks with unique placeholders.
+
+    Code content must never be transformed by the Unicode mapping steps.
+    Placeholders are UUID-based so they cannot accidentally match user text.
+
+    Args:
+        text: Markdown text.
+
+    Returns:
+        A ``(modified_text, placeholder_map)`` tuple where *placeholder_map*
+        maps each placeholder back to its original code string.
+    """
+    placeholders: dict[str, str] = {}
+
+    def _replace(match: re.Match[str]) -> str:
+        key = f"\x00CODE{uuid.uuid4().hex}\x00"
+        placeholders[key] = match.group(0)
+        return key
+
+    # Fenced code blocks (``` or ~~~, with optional language tag)
+    text = re.sub(r"```[\s\S]*?```|~~~[\s\S]*?~~~", _replace, text)
+    # Inline code spans (single backtick only; triple already caught above)
+    text = re.sub(r"`[^`\n]+`", _replace, text)
+    return text, placeholders
+
+
+def _restore_code(text: str, placeholders: dict[str, str]) -> str:
+    """Restore code placeholders to their original content.
+
+    For inline code, the surrounding backticks are stripped (the plain text
+    content is kept). For fenced blocks, the entire original block is kept
+    intact so structure is preserved.
+
+    Args:
+        text: Text containing placeholders.
+        placeholders: Map of placeholder → original code string.
+
+    Returns:
+        Text with all placeholders replaced by their original code content.
+    """
+    for key, original in placeholders.items():
+        if original.startswith(("```", "~~~")):
+            # Keep fenced blocks as-is (no backtick stripping)
+            text = text.replace(key, original)
+        else:
+            # Strip the surrounding backticks for inline code
+            text = text.replace(key, original[1:-1])
+    return text
+
+
+def _strip_html_spans(text: str) -> str:
+    """Remove ``<span ...>...</span>`` wrappers, keeping inner text.
+
+    Iterates until no more span tags remain so that arbitrarily nested
+    spans are fully unwrapped.
+
+    Args:
+        text: Input text that may contain HTML span elements.
+
+    Returns:
+        Text with all span elements removed and their inner content preserved.
+    """
+    prev = None
+    while prev != text:
+        prev = text
+        text = re.sub(r"<span[^>]*>(.*?)</span>", r"\1", text, flags=re.DOTALL)
+    return text
+
+
+def _convert_bold_italic(text: str) -> str:
+    """Replace ``***text***`` (or ``___text___``) with bold-italic Unicode.
+
+    Must run before :func:`_convert_bold` and :func:`_convert_italic` to
+    prevent the triple markers from being consumed piecemeal.
+
+    Backslash-escaped markers (``\\***``) are not matched.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with bold-italic markers replaced.
+    """
+    text = re.sub(
+        r"(?<!\\)\*{3}(.+?)(?<!\\)\*{3}",
+        lambda m: to_sans_bold_italic(m.group(1)),
+        text,
+    )
+    return re.sub(
+        r"(?<!\\)_{3}(.+?)(?<!\\)_{3}",
+        lambda m: to_sans_bold_italic(m.group(1)),
+        text,
+    )
+
+
+def _convert_bold(text: str) -> str:
+    """Replace ``**text**`` (or ``__text__``) with bold Unicode.
+
+    Backslash-escaped markers (``\\**``) are not matched.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with bold markers replaced.
+    """
+    text = re.sub(
+        r"(?<!\\)\*{2}(.+?)(?<!\\)\*{2}",
+        lambda m: to_sans_bold(m.group(1)),
+        text,
+    )
+    return re.sub(
+        r"(?<!\\)__(.+?)(?<!\\)__",
+        lambda m: to_sans_bold(m.group(1)),
+        text,
+    )
+
+
+def _convert_italic(text: str) -> str:
+    """Replace ``*text*`` or ``_text_`` with italic Unicode.
+
+    Uses negative look-around to avoid matching asterisks that are part of
+    bold (``**``) or bold-italic (``***``) markers already consumed by
+    earlier pipeline steps. Backslash-escaped markers (``\\*``) are also
+    not matched.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with italic markers replaced.
+    """
+    # *text* — negative look-around prevents matching residual ** markers or \* escapes
+    text = re.sub(
+        r"(?<!\\)(?<!\*)\*(?!\*)(.+?)(?<!\\)(?<!\*)\*(?!\*)",
+        lambda m: to_sans_italic(m.group(1)),
+        text,
+    )
+    # _text_ — word-boundary anchors prevent matching inside_words; skip \_ escapes
+    return re.sub(
+        r"(?<!\w)(?<!\\)_(?!_)(.+?)(?<!\\)(?<!_)_(?!\w)",
+        lambda m: to_sans_italic(m.group(1)),
+        text,
+    )
+
+
+def _convert_headers(text: str) -> str:
+    """Convert ATX headers (``# Heading``) and setext headers to styled text.
+
+    * H1 (``#`` or setext ``===``): bold Unicode + ``━`` border.
+    * H2–H6 (``##``–``######`` or setext ``---``): bold Unicode, no border.
+
+    Args:
+        text: Input text with Markdown headers.
+
+    Returns:
+        Text with headers replaced by styled plain text.
+    """
+    separator = "━" * 40
+
+    def _fmt_h1(title: str) -> str:
+        clean = title.strip()
+        return f"\n{separator}\n{to_sans_bold(clean.upper())}\n{separator}\n"
+
+    def _fmt_h2(title: str) -> str:
+        return to_sans_bold(title.strip())
+
+    lines = text.split("\n")
+    out: list[str] = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        # ATX headers
+        atx = re.match(r"^(#{1,6})\s+(.*)", line)
+        if atx:
+            level = len(atx.group(1))
+            title = atx.group(2).rstrip()
+            if level == 1:
+                out.append(_fmt_h1(title))
+            else:
+                out.append(_fmt_h2(title))
+            i += 1
+            continue
+        # Setext headers: next line is === or ---
+        if i + 1 < len(lines):
+            next_line = lines[i + 1]
+            if re.match(r"^={3,}\s*$", next_line):
+                out.append(_fmt_h1(line))
+                i += 2
+                continue
+            if re.match(r"^-{3,}\s*$", next_line) and line.strip():
+                out.append(_fmt_h2(line))
+                i += 2
+                continue
+        # Standalone horizontal rules (---, ___, ***)
+        if re.match(r"^(-{3,}|_{3,}|\*{3,})\s*$", line):
+            i += 1
+            continue
+        out.append(line)
+        i += 1
+    return "\n".join(out)
+
+
+def _strip_links(text: str, *, preserve: bool = False) -> str:
+    """Handle Markdown links.
+
+    By default, links are stripped to their display text only (URLs are
+    discarded). Empty links ``[](url)`` are removed entirely. Reference-style
+    links ``[text][ref]`` are reduced to their display text.
+
+    When *preserve* is ``True`` the full link syntax is retained as-is.
+
+    Args:
+        text: Input text.
+        preserve: When ``True``, leave link syntax unchanged.
+
+    Returns:
+        Text with links handled according to *preserve*.
+    """
+    if preserve:
+        return text
+    # Remove empty links [](url)
+    text = re.sub(r"\[\]\([^)]*\)", "", text)
+    # Inline links [text](url "optional title") → text
+    text = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", text)
+    # Reference-style links [text][ref] → text
+    text = re.sub(r"\[([^\]]+)\]\[[^\]]*\]", r"\1", text)
+    # Autolinks <https://example.com> → https://example.com
+    return re.sub(r"<(https?://[^>]+)>", r"\1", text)
+
+
+def _strip_images(text: str) -> str:
+    """Replace Markdown images with their alt text (or nothing if empty).
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with image syntax replaced by alt text.
+    """
+    # ![alt](url) → alt  (empty alt → removed)
+    return re.sub(
+        r"!\[([^\]]*)\]\([^)]*\)",
+        lambda m: m.group(1) or "",
+        text,
+    )
+
+
+def _convert_bullets(text: str) -> str:
+    """Replace Markdown list markers with Unicode bullet characters.
+
+    * First-level ``- `` → ``• ``
+    * Second-level ``  - `` (2+ leading spaces) → ``  ‣ ``
+    * Ordered list markers (``1. ``) are left as-is (numbers already convey order).
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with list markers replaced.
+    """
+
+    def _bullet(m: re.Match[str]) -> str:
+        indent = m.group(1)
+        return ("  ‣ " if len(indent) >= _NESTED_BULLET_MIN_INDENT else "• ")
+
+    return re.sub(r"^(\s*)[-*+] ", _bullet, text, flags=re.MULTILINE)
+
+
+def _strip_blockquotes(text: str) -> str:
+    """Remove leading ``>`` blockquote markers.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with blockquote markers stripped from line beginnings.
+    """
+    return re.sub(r"^> ?", "", text, flags=re.MULTILINE)
+
+
+def _clean_entities(text: str) -> str:
+    """Decode common HTML entities to their literal characters.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with ``&gt;``, ``&lt;``, ``&amp;``, ``&nbsp;``, ``&quot;``
+        replaced by their literal equivalents.
+    """
+    replacements = {
+        "&gt;": ">",
+        "&lt;": "<",
+        "&amp;": "&",
+        "&nbsp;": " ",
+        "&quot;": '"',
+        "&apos;": "'",
+    }
+    for entity, char in replacements.items():
+        text = text.replace(entity, char)
+    return text
+
+
+def _clean_escaped_chars(text: str) -> str:
+    """Remove Markdown backslash escapes (e.g. ``\\*`` → ``*``).
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Text with backslash escapes resolved.
+    """
+    return re.sub(r"\\([\\`*_{}\[\]()#+\-.!])", r"\1", text)
+
+
+def _normalize_whitespace(text: str) -> str:
+    """Collapse excessive blank lines and strip leading/trailing whitespace.
+
+    LinkedIn renders at most two consecutive blank lines meaningfully, so
+    three or more consecutive newlines are collapsed to two.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Normalized text with a single trailing newline.
+    """
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip() + "\n"
+
+
+# ── Public API ─────────────────────────────────────────────────────────────────
+
+
+def convert(text: str, *, preserve_links: bool = False) -> str:
+    """Convert Markdown text to LinkedIn-compatible Unicode plain text.
+
+    Bold (``**text**`` / ``__text__``), italic (``*text*`` / ``_text_``), and
+    bold-italic (``***text***`` / ``___text___``) markers are replaced with
+    their Unicode Mathematical Sans-Serif equivalents so that the styling is
+    preserved when pasting into LinkedIn or other plain-text rich editors.
+
+    The following Markdown constructs are also handled:
+
+    * **Headers** — ATX (``#``) and setext styles; H1 gets a ``━`` border.
+    * **Code spans** — backticks stripped, content kept as plain text.
+    * **Fenced code blocks** — preserved verbatim (no Unicode transforms).
+    * **Links** — stripped to display text by default (see *preserve_links*).
+    * **Images** — replaced by alt text.
+    * **Bullet lists** — ``-`` / ``*`` / ``+`` → ``•`` / ``‣`` (nested).
+    * **Blockquotes** — leading ``>`` stripped.
+    * **HTML spans** — unwrapped, inner text kept.
+    * **HTML entities** — decoded to literal characters.
+    * **Backslash escapes** — resolved (``\\*`` → ``*``).
+    * **Windows line endings** — normalised to ``\\n``.
+
+    Args:
+        text: The Markdown source string.
+        preserve_links: When ``True``, link syntax (``[text](url)``) is left
+            unchanged in the output instead of being reduced to display text.
+
+    Returns:
+        A plain-text string suitable for pasting into LinkedIn.
+
+    Examples:
+        >>> convert("**Hello**, *world*!")
+        '𝗛𝗲𝗹𝗹𝗼, 𝘸𝘰𝘳𝘭𝘥!\\n'
+
+        >>> convert("")
+        ''
+    """
+    if not text or not text.strip():
+        return ""
+
+    text = _normalize_line_endings(text)
+    text, placeholders = _protect_code(text)
+    text = _strip_html_spans(text)
+    text = _strip_images(text)
+    text = _convert_bold_italic(text)
+    text = _convert_bold(text)
+    text = _convert_italic(text)
+    text = _convert_headers(text)
+    text = _strip_links(text, preserve=preserve_links)
+    text = _convert_bullets(text)
+    text = _strip_blockquotes(text)
+    text = _restore_code(text, placeholders)
+    text = _clean_entities(text)
+    text = _clean_escaped_chars(text)
+    return _normalize_whitespace(text)
+
+
+def convert_file(
+    input_path: str | Path,
+    output_path: str | Path | None = None,
+    *,
+    preserve_links: bool = False,
+) -> Path:
+    """Convert a Markdown file and write the result to a ``.txt`` file.
+
+    Args:
+        input_path: Path to the Markdown source file (``.md`` or any text
+            file).
+        output_path: Destination path for the converted output.  Defaults to
+            the input path with the extension replaced by
+            ``.linkedin.txt``.
+        preserve_links: Passed through to :func:`convert`.
+
+    Returns:
+        The resolved path of the written output file.
+
+    Raises:
+        FileNotFoundError: If *input_path* does not exist.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> import tempfile, os
+        >>> with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
+        ...     _ = f.write("**bold** and *italic*")
+        ...     tmp = f.name
+        >>> out = convert_file(tmp)
+        >>> out.read_text(encoding="utf-8")
+        '𝗯𝗼𝗹𝗱 and 𝘪𝘵𝘢𝘭𝘪𝘤\\n'
+        >>> os.unlink(tmp); os.unlink(str(out))
+    """
+    input_path = Path(input_path)
+    if not input_path.exists():
+        msg = f"Input file not found: {input_path}"
+        raise FileNotFoundError(msg)
+
+    if output_path is None:
+        output_path = input_path.with_suffix("").with_suffix(".linkedin.txt")
+    output_path = Path(output_path)
+
+    md_text = input_path.read_text(encoding="utf-8")
+    result = convert(md_text, preserve_links=preserve_links)
+    output_path.write_text(result, encoding="utf-8")
+    return output_path

md2linkedin-0.1.0/src/md2linkedin/_unicode.py

@@ -0,0 +1,169 @@
+"""Unicode Mathematical Sans-Serif character mapping functions.
+
+Converts ASCII letters and digits to their Unicode Mathematical
+Sans-Serif equivalents, enabling bold, italic, and bold-italic
+styling in plain-text environments like LinkedIn.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+__all__ = ["apply_style", "to_sans_bold", "to_sans_bold_italic", "to_sans_italic"]
+
+# ── Unicode block offsets ──────────────────────────────────────────────────────
+# Reference: Unicode Mathematical Alphanumeric Symbols (U+1D400–U+1D7FF)
+
+_SANS_BOLD_UPPER = 0x1D5D4  # 𝗔
+_SANS_BOLD_LOWER = 0x1D5EE  # 𝗮
+_SANS_BOLD_DIGIT = 0x1D7EC  # 𝟬
+
+_SANS_ITALIC_UPPER = 0x1D608  # 𝘈
+_SANS_ITALIC_LOWER = 0x1D622  # 𝘢
+
+_SANS_BOLD_ITALIC_UPPER = 0x1D63C  # 𝘼
+_SANS_BOLD_ITALIC_LOWER = 0x1D656  # 𝙖
+
+
+# ── Public mapping functions ───────────────────────────────────────────────────
+
+
+def to_sans_bold(text: str) -> str:
+    """Convert text to Unicode Mathematical Sans-Serif Bold.
+
+    ASCII uppercase letters, lowercase letters, and digits are mapped to
+    their bold sans-serif counterparts. All other characters (spaces,
+    punctuation, non-ASCII) pass through unchanged.
+
+    Args:
+        text: The input string to convert.
+
+    Returns:
+        A new string with ASCII alphanumerics replaced by bold sans-serif
+        Unicode equivalents.
+
+    Examples:
+        >>> to_sans_bold("Hello, World! 123")
+        '𝗛𝗲𝗹𝗹𝗼, 𝗪𝗼𝗿𝗹𝗱! 𝟭𝟮𝟯'
+
+        >>> to_sans_bold("café")
+        '𝗰𝗮𝗳é'
+
+        >>> to_sans_bold("")
+        ''
+    """
+    out: list[str] = []
+    for c in text:
+        if "A" <= c <= "Z":
+            out.append(chr(_SANS_BOLD_UPPER + ord(c) - ord("A")))
+        elif "a" <= c <= "z":
+            out.append(chr(_SANS_BOLD_LOWER + ord(c) - ord("a")))
+        elif "0" <= c <= "9":
+            out.append(chr(_SANS_BOLD_DIGIT + ord(c) - ord("0")))
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def to_sans_italic(text: str) -> str:
+    """Convert text to Unicode Mathematical Sans-Serif Italic.
+
+    ASCII uppercase and lowercase letters are mapped to their italic
+    sans-serif counterparts. Digits and all other characters pass through
+    unchanged (there are no italic digit codepoints in this Unicode block).
+
+    Args:
+        text: The input string to convert.
+
+    Returns:
+        A new string with ASCII letters replaced by italic sans-serif
+        Unicode equivalents.
+
+    Examples:
+        >>> to_sans_italic("Hello, World!")
+        '𝘏𝘦𝘭𝘭𝘰, 𝘞𝘰𝘳𝘭𝘥!'
+
+        >>> to_sans_italic("price: $42")
+        '𝘱𝘳𝘪𝘤𝘦: $42'
+
+        >>> to_sans_italic("")
+        ''
+    """
+    out: list[str] = []
+    for c in text:
+        if "A" <= c <= "Z":
+            out.append(chr(_SANS_ITALIC_UPPER + ord(c) - ord("A")))
+        elif "a" <= c <= "z":
+            out.append(chr(_SANS_ITALIC_LOWER + ord(c) - ord("a")))
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def to_sans_bold_italic(text: str) -> str:
+    """Convert text to Unicode Mathematical Sans-Serif Bold Italic.
+
+    ASCII uppercase and lowercase letters are mapped to their bold-italic
+    sans-serif counterparts. Digits and all other characters pass through
+    unchanged.
+
+    Args:
+        text: The input string to convert.
+
+    Returns:
+        A new string with ASCII letters replaced by bold-italic sans-serif
+        Unicode equivalents.
+
+    Examples:
+        >>> to_sans_bold_italic("Hello, World!")
+        '𝘼𝙡𝙡𝙤, 𝙒𝙤𝙧𝙡𝙙!'
+
+        >>> to_sans_bold_italic("")
+        ''
+    """
+    out: list[str] = []
+    for c in text:
+        if "A" <= c <= "Z":
+            out.append(chr(_SANS_BOLD_ITALIC_UPPER + ord(c) - ord("A")))
+        elif "a" <= c <= "z":
+            out.append(chr(_SANS_BOLD_ITALIC_LOWER + ord(c) - ord("a")))
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def apply_style(text: str, style: Literal["bold", "italic", "bold_italic"]) -> str:
+    """Apply a Unicode sans-serif style to text.
+
+    A convenience dispatcher that routes to the appropriate mapping function
+    based on the requested style. Useful when the style is determined
+    dynamically at runtime.
+
+    Args:
+        text: The input string to convert.
+        style: One of ``"bold"``, ``"italic"``, or ``"bold_italic"``.
+
+    Returns:
+        A new string with the requested Unicode style applied.
+
+    Raises:
+        ValueError: If *style* is not one of the three accepted values.
+
+    Examples:
+        >>> apply_style("hello", "bold")
+        '𝗵𝗲𝗹𝗹𝗼'
+
+        >>> apply_style("hello", "italic")
+        '𝘩𝘦𝘭𝘭𝘰'
+
+        >>> apply_style("hello", "bold_italic")
+        '𝙝𝙚𝙡𝙡𝙤'
+    """
+    if style == "bold":
+        return to_sans_bold(text)
+    if style == "italic":
+        return to_sans_italic(text)
+    if style == "bold_italic":
+        return to_sans_bold_italic(text)
+    msg = f"Unknown style {style!r}. Expected 'bold', 'italic', or 'bold_italic'."
+    raise ValueError(msg)