md2mrkdwn 0.1.0__tar.gz

md2mrkdwn-0.1.0/.gitignore

@@ -0,0 +1,77 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+.idea
+media
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+configs/local_settings.py
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+#Ipython Notebook
+.ipynb_checkpoints
+venv/*
+env/*
+.venv/*
+.env/*
+
+# Idea modules
+*.iml
+
+.ruff_cache
+.pytest_cache
+.mypy_cache
+
+.claude/
+CLAUDE.MD

md2mrkdwn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dave Allie
+
+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.

md2mrkdwn-0.1.0/PKG-INFO

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: md2mrkdwn
+Version: 0.1.0
+Summary: Convert Markdown to Slack mrkdwn format
+Project-URL: Homepage, https://github.com/bigbag/md2mrkdwn
+Project-URL: Repository, https://github.com/bigbag/md2mrkdwn
+Project-URL: Issues, https://github.com/bigbag/md2mrkdwn/issues
+Author-email: Pavel Liashkov <pavel.liashkov@protonamil.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: converter,formatting,markdown,mrkdwn,slack
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Communications :: Chat
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# md2mrkdwn
+
+[![CI](https://github.com/bigbag/md2mrkdwn/workflows/CI/badge.svg)](https://github.com/bigbag/md2mrkdwn/actions?query=workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/md2mrkdwn.svg)](https://pypi.python.org/pypi/md2mrkdwn)
+[![downloads](https://img.shields.io/pypi/dm/md2mrkdwn.svg)](https://pypistats.org/packages/md2mrkdwn)
+[![versions](https://img.shields.io/pypi/pyversions/md2mrkdwn.svg)](https://github.com/bigbag/md2mrkdwn)
+[![license](https://img.shields.io/github/license/bigbag/md2mrkdwn.svg)](https://github.com/bigbag/md2mrkdwn/blob/master/LICENSE)
+
+Pure Python library for converting Markdown to Slack's mrkdwn format. Zero dependencies, comprehensive formatting support, and proper handling of edge cases.
+
+## Features
+
+- **Zero dependencies** - Pure Python implementation with no external packages required
+- **Comprehensive formatting** - Supports bold, italic, strikethrough, links, images, lists, and more
+- **Code block handling** - Preserves content inside code blocks without conversion
+- **Table support** - Wraps markdown tables in code blocks for Slack display
+- **Task lists** - Converts checkbox syntax to Unicode symbols (☐/☑)
+- **Edge case handling** - Properly handles nested formatting and special characters
+
+## Quick Start
+
+```python
+from md2mrkdwn import convert
+
+markdown = "**Hello** *World*! Check out [Slack](https://slack.com)"
+mrkdwn = convert(markdown)
+print(mrkdwn)
+# Output: *Hello* _World_! Check out <https://slack.com|Slack>
+```
+
+## Installation
+
+```bash
+# Install with pip
+pip install md2mrkdwn
+
+# Or install with uv
+uv add md2mrkdwn
+
+# Or install with pipx (for CLI tools that use this library)
+pipx install md2mrkdwn
+```
+
+## Usage
+
+### Simple Function
+
+The `convert()` function provides a simple interface for one-off conversions:
+
+```python
+from md2mrkdwn import convert
+
+markdown = """
+# Hello World
+
+This is **bold** and *italic* text.
+
+- Item 1
+- Item 2
+
+Check out [this link](https://example.com)!
+"""
+
+mrkdwn = convert(markdown)
+print(mrkdwn)
+```
+
+Output:
+```
+*Hello World*
+
+This is *bold* and _italic_ text.
+
+• Item 1
+• Item 2
+
+Check out <https://example.com|this link>!
+```
+
+### Class-based Usage
+
+For multiple conversions, use the `MrkdwnConverter` class:
+
+```python
+from md2mrkdwn import MrkdwnConverter
+
+converter = MrkdwnConverter()
+
+# Convert multiple texts
+text1 = converter.convert("**bold** and *italic*")
+text2 = converter.convert("# Header\n\n- List item")
+
+print(text1)  # *bold* and _italic_
+print(text2)  # *Header*\n\n• List item
+```
+
+### Handling Tables
+
+Markdown tables are automatically wrapped in code blocks since Slack doesn't support native table rendering:
+
+```python
+from md2mrkdwn import convert
+
+markdown = """
+| Name | Age |
+|------|-----|
+| Alice | 30 |
+| Bob | 25 |
+"""
+
+print(convert(markdown))
+```
+
+Output:
+```
+```
+| Name | Age |
+|------|-----|
+| Alice | 30 |
+| Bob | 25 |
+```
+```
+
+## Conversion Reference
+
+| Markdown | mrkdwn | Notes |
+|----------|--------|-------|
+| `**bold**` or `__bold__` | `*bold*` | Slack uses single asterisk |
+| `*italic*` or `_italic_` | `_italic_` | Slack uses underscores |
+| `***bold+italic***` | `*_text_*` | Combined formatting |
+| `~~strikethrough~~` | `~text~` | Single tilde |
+| `[text](url)` | `<url\|text>` | Slack link format |
+| `![alt](url)` | `<url>` | Images become plain URLs |
+| `# Header` (all levels) | `*Header*` | Bold (Slack has no headers) |
+| `- item` / `* item` | `• item` | Bullet character (U+2022) |
+| `1. item` | `1. item` | Preserved as-is |
+| `- [ ] task` | `• ☐ task` | Unchecked checkbox (U+2610) |
+| `- [x] task` | `• ☑ task` | Checked checkbox (U+2611) |
+| `> quote` | `> quote` | Same syntax |
+| `` `code` `` | `` `code` `` | Same syntax |
+| ``` code block ``` | ``` code block ``` | Same syntax |
+| `---` / `***` | `──────────` | Horizontal rule (U+2500) |
+| Tables | Wrapped in ``` | Slack has no native tables |
+
+## How It Works
+
+### Conversion Pipeline
+
+md2mrkdwn processes text through a multi-stage pipeline:
+
+1. **Table extraction** - Tables are detected, validated, and replaced with placeholders
+2. **Code block tracking** - Lines inside code blocks are skipped during conversion
+3. **Pattern application** - Regex patterns convert formatting using placeholder protection
+4. **Placeholder restoration** - Tables and temporary markers are replaced with final output
+
+### Pattern Interference Prevention
+
+A key challenge in markdown conversion is preventing patterns from interfering with each other. For example, converting `**bold**` to `*bold*` could then be matched by the italic pattern.
+
+md2mrkdwn solves this using placeholder substitution:
+1. Bold text is temporarily marked with null-byte placeholders
+2. Italic patterns run without matching the placeholders
+3. Placeholders are replaced with final mrkdwn characters
+
+### Table Handling
+
+Tables are detected using these criteria:
+- Lines matching `|...|` pattern
+- Second row contains separator cells (dashes with optional alignment colons)
+- Header and separator have matching column counts
+
+Valid tables are wrapped in triple-backtick code blocks for monospace display in Slack.
+
+### Code Block Protection
+
+Content inside code blocks (both fenced and inline) is protected from conversion:
+- Fenced blocks: State machine tracks opening/closing ``` markers
+- Inline code: Segments are extracted before conversion and restored after
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/bigbag/md2mrkdwn.git
+cd md2mrkdwn
+make install
+```
+
+### Commands
+
+```bash
+make install  # Install all dependencies
+make test     # Run tests with coverage
+make lint     # Run linters (ruff + mypy)
+make format   # Format code with ruff
+make clean    # Clean cache and build files
+```
+
+### Running Tests
+
+```bash
+# Run all tests with coverage
+uv run pytest --cov=md2mrkdwn --cov-report=term-missing
+
+# Run specific test class
+uv run pytest tests/test_converter.py::TestBasicFormatting -v
+
+# Run with verbose output
+uv run pytest -v
+```
+
+### Project Structure
+
+```
+md2mrkdwn/
+├── src/
+│   └── md2mrkdwn/
+│       ├── __init__.py      # Package exports
+│       └── converter.py     # MrkdwnConverter class
+├── tests/
+│   ├── conftest.py          # Pytest fixtures
+│   └── test_converter.py    # Test suite (49 tests)
+├── pyproject.toml           # Project configuration
+├── Makefile                 # Development commands
+└── README.md
+```
+
+## API Reference
+
+### `convert(markdown: str) -> str`
+
+Convert Markdown text to Slack mrkdwn format.
+
+**Parameters:**
+- `markdown` - Input text in Markdown format
+
+**Returns:**
+- Text converted to Slack mrkdwn format
+
+### `MrkdwnConverter`
+
+Class for converting Markdown to mrkdwn.
+
+**Methods:**
+- `convert(markdown: str) -> str` - Convert Markdown text to mrkdwn
+
+**Example:**
+```python
+converter = MrkdwnConverter()
+result = converter.convert("**Hello** *World*")
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.

md2mrkdwn-0.1.0/README.md

@@ -0,0 +1,256 @@
+# md2mrkdwn
+
+[![CI](https://github.com/bigbag/md2mrkdwn/workflows/CI/badge.svg)](https://github.com/bigbag/md2mrkdwn/actions?query=workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/md2mrkdwn.svg)](https://pypi.python.org/pypi/md2mrkdwn)
+[![downloads](https://img.shields.io/pypi/dm/md2mrkdwn.svg)](https://pypistats.org/packages/md2mrkdwn)
+[![versions](https://img.shields.io/pypi/pyversions/md2mrkdwn.svg)](https://github.com/bigbag/md2mrkdwn)
+[![license](https://img.shields.io/github/license/bigbag/md2mrkdwn.svg)](https://github.com/bigbag/md2mrkdwn/blob/master/LICENSE)
+
+Pure Python library for converting Markdown to Slack's mrkdwn format. Zero dependencies, comprehensive formatting support, and proper handling of edge cases.
+
+## Features
+
+- **Zero dependencies** - Pure Python implementation with no external packages required
+- **Comprehensive formatting** - Supports bold, italic, strikethrough, links, images, lists, and more
+- **Code block handling** - Preserves content inside code blocks without conversion
+- **Table support** - Wraps markdown tables in code blocks for Slack display
+- **Task lists** - Converts checkbox syntax to Unicode symbols (☐/☑)
+- **Edge case handling** - Properly handles nested formatting and special characters
+
+## Quick Start
+
+```python
+from md2mrkdwn import convert
+
+markdown = "**Hello** *World*! Check out [Slack](https://slack.com)"
+mrkdwn = convert(markdown)
+print(mrkdwn)
+# Output: *Hello* _World_! Check out <https://slack.com|Slack>
+```
+
+## Installation
+
+```bash
+# Install with pip
+pip install md2mrkdwn
+
+# Or install with uv
+uv add md2mrkdwn
+
+# Or install with pipx (for CLI tools that use this library)
+pipx install md2mrkdwn
+```
+
+## Usage
+
+### Simple Function
+
+The `convert()` function provides a simple interface for one-off conversions:
+
+```python
+from md2mrkdwn import convert
+
+markdown = """
+# Hello World
+
+This is **bold** and *italic* text.
+
+- Item 1
+- Item 2
+
+Check out [this link](https://example.com)!
+"""
+
+mrkdwn = convert(markdown)
+print(mrkdwn)
+```
+
+Output:
+```
+*Hello World*
+
+This is *bold* and _italic_ text.
+
+• Item 1
+• Item 2
+
+Check out <https://example.com|this link>!
+```
+
+### Class-based Usage
+
+For multiple conversions, use the `MrkdwnConverter` class:
+
+```python
+from md2mrkdwn import MrkdwnConverter
+
+converter = MrkdwnConverter()
+
+# Convert multiple texts
+text1 = converter.convert("**bold** and *italic*")
+text2 = converter.convert("# Header\n\n- List item")
+
+print(text1)  # *bold* and _italic_
+print(text2)  # *Header*\n\n• List item
+```
+
+### Handling Tables
+
+Markdown tables are automatically wrapped in code blocks since Slack doesn't support native table rendering:
+
+```python
+from md2mrkdwn import convert
+
+markdown = """
+| Name | Age |
+|------|-----|
+| Alice | 30 |
+| Bob | 25 |
+"""
+
+print(convert(markdown))
+```
+
+Output:
+```
+```
+| Name | Age |
+|------|-----|
+| Alice | 30 |
+| Bob | 25 |
+```
+```
+
+## Conversion Reference
+
+| Markdown | mrkdwn | Notes |
+|----------|--------|-------|
+| `**bold**` or `__bold__` | `*bold*` | Slack uses single asterisk |
+| `*italic*` or `_italic_` | `_italic_` | Slack uses underscores |
+| `***bold+italic***` | `*_text_*` | Combined formatting |
+| `~~strikethrough~~` | `~text~` | Single tilde |
+| `[text](url)` | `<url\|text>` | Slack link format |
+| `![alt](url)` | `<url>` | Images become plain URLs |
+| `# Header` (all levels) | `*Header*` | Bold (Slack has no headers) |
+| `- item` / `* item` | `• item` | Bullet character (U+2022) |
+| `1. item` | `1. item` | Preserved as-is |
+| `- [ ] task` | `• ☐ task` | Unchecked checkbox (U+2610) |
+| `- [x] task` | `• ☑ task` | Checked checkbox (U+2611) |
+| `> quote` | `> quote` | Same syntax |
+| `` `code` `` | `` `code` `` | Same syntax |
+| ``` code block ``` | ``` code block ``` | Same syntax |
+| `---` / `***` | `──────────` | Horizontal rule (U+2500) |
+| Tables | Wrapped in ``` | Slack has no native tables |
+
+## How It Works
+
+### Conversion Pipeline
+
+md2mrkdwn processes text through a multi-stage pipeline:
+
+1. **Table extraction** - Tables are detected, validated, and replaced with placeholders
+2. **Code block tracking** - Lines inside code blocks are skipped during conversion
+3. **Pattern application** - Regex patterns convert formatting using placeholder protection
+4. **Placeholder restoration** - Tables and temporary markers are replaced with final output
+
+### Pattern Interference Prevention
+
+A key challenge in markdown conversion is preventing patterns from interfering with each other. For example, converting `**bold**` to `*bold*` could then be matched by the italic pattern.
+
+md2mrkdwn solves this using placeholder substitution:
+1. Bold text is temporarily marked with null-byte placeholders
+2. Italic patterns run without matching the placeholders
+3. Placeholders are replaced with final mrkdwn characters
+
+### Table Handling
+
+Tables are detected using these criteria:
+- Lines matching `|...|` pattern
+- Second row contains separator cells (dashes with optional alignment colons)
+- Header and separator have matching column counts
+
+Valid tables are wrapped in triple-backtick code blocks for monospace display in Slack.
+
+### Code Block Protection
+
+Content inside code blocks (both fenced and inline) is protected from conversion:
+- Fenced blocks: State machine tracks opening/closing ``` markers
+- Inline code: Segments are extracted before conversion and restored after
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/bigbag/md2mrkdwn.git
+cd md2mrkdwn
+make install
+```
+
+### Commands
+
+```bash
+make install  # Install all dependencies
+make test     # Run tests with coverage
+make lint     # Run linters (ruff + mypy)
+make format   # Format code with ruff
+make clean    # Clean cache and build files
+```
+
+### Running Tests
+
+```bash
+# Run all tests with coverage
+uv run pytest --cov=md2mrkdwn --cov-report=term-missing
+
+# Run specific test class
+uv run pytest tests/test_converter.py::TestBasicFormatting -v
+
+# Run with verbose output
+uv run pytest -v
+```
+
+### Project Structure
+
+```
+md2mrkdwn/
+├── src/
+│   └── md2mrkdwn/
+│       ├── __init__.py      # Package exports
+│       └── converter.py     # MrkdwnConverter class
+├── tests/
+│   ├── conftest.py          # Pytest fixtures
+│   └── test_converter.py    # Test suite (49 tests)
+├── pyproject.toml           # Project configuration
+├── Makefile                 # Development commands
+└── README.md
+```
+
+## API Reference
+
+### `convert(markdown: str) -> str`
+
+Convert Markdown text to Slack mrkdwn format.
+
+**Parameters:**
+- `markdown` - Input text in Markdown format
+
+**Returns:**
+- Text converted to Slack mrkdwn format
+
+### `MrkdwnConverter`
+
+Class for converting Markdown to mrkdwn.
+
+**Methods:**
+- `convert(markdown: str) -> str` - Convert Markdown text to mrkdwn
+
+**Example:**
+```python
+converter = MrkdwnConverter()
+result = converter.convert("**Hello** *World*")
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.

md2mrkdwn-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "md2mrkdwn"
+version = "0.1.0"
+description = "Convert Markdown to Slack mrkdwn format"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Pavel Liashkov", email = "pavel.liashkov@protonamil.com" }]
+keywords = ["markdown", "slack", "mrkdwn", "converter", "formatting"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "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",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Communications :: Chat",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/bigbag/md2mrkdwn"
+Repository = "https://github.com/bigbag/md2mrkdwn"
+Issues = "https://github.com/bigbag/md2mrkdwn/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/md2mrkdwn"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/md2mrkdwn"]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.16.0",
+    "pyclean>=3.1.0",
+    "pytest>=8.4.0",
+    "pytest-cov>=6.1.1",
+    "pytest-mock>=3.14.1",
+    "ruff>=0.9.0",
+]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "C4", "UP", "SIM"]
+ignore = ["E203", "E501", "B008"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short --cov=md2mrkdwn --cov-report=term-missing"
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.coverage.run]
+source = ["src/md2mrkdwn"]
+omit = ["tests/*"]

md2mrkdwn-0.1.0/src/md2mrkdwn/__init__.py

@@ -0,0 +1,6 @@
+"""md2mrkdwn - Convert Markdown to Slack mrkdwn format."""
+
+from md2mrkdwn.converter import MrkdwnConverter, convert
+
+__version__ = "0.1.0"
+__all__ = ["MrkdwnConverter", "convert", "__version__"]

md2mrkdwn-0.1.0/src/md2mrkdwn/converter.py

@@ -0,0 +1,386 @@
+"""Markdown to Slack mrkdwn converter."""
+
+import hashlib
+import re
+
+# =============================================================================
+# Compiled regex patterns (module-level for efficiency)
+# =============================================================================
+
+# Table detection
+TABLE_ROW_PATTERN = re.compile(r"^\s*\|.+\|\s*$")
+SEPARATOR_CELL_PATTERN = re.compile(r"^:?[-\u2013\u2014\u2212]+:?$")
+
+# Markdown formatting (for stripping inside code blocks)
+BOLD_STRIP_PATTERN = re.compile(r"\*\*(.+?)\*\*")
+ITALIC_STRIP_PATTERN = re.compile(r"\*(.+?)\*")
+
+# Inline code protection
+INLINE_CODE_PATTERN = re.compile(r"`[^`]+`")
+
+# Conversion patterns
+HEADER_PATTERN = re.compile(r"^#{1,6}\s+(.+?)(?:\s+#+)?$", re.MULTILINE)
+BOLD_ITALIC_ASTERISKS_PATTERN = re.compile(r"\*\*\*(.+?)\*\*\*")
+BOLD_ITALIC_UNDERSCORES_PATTERN = re.compile(r"___(.+?)___")
+BOLD_ASTERISKS_PATTERN = re.compile(r"\*\*(.+?)\*\*")
+BOLD_UNDERSCORES_PATTERN = re.compile(r"__(.+?)__")
+ITALIC_ASTERISKS_PATTERN = re.compile(r"(?<!\*)\*([^*]+?)\*(?!\*)")
+ITALIC_UNDERSCORES_PATTERN = re.compile(r"(?<!_)_([^_]+?)_(?!_)")
+STRIKETHROUGH_PATTERN = re.compile(r"~~(.+?)~~")
+IMAGE_PATTERN = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
+LINK_PATTERN = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+TASK_CHECKED_PATTERN = re.compile(r"^(\s*)[-*+]\s+\[x\]\s*", re.MULTILINE | re.IGNORECASE)
+TASK_UNCHECKED_PATTERN = re.compile(r"^(\s*)[-*+]\s+\[ \]\s*", re.MULTILINE)
+UNORDERED_LIST_PATTERN = re.compile(r"^(\s*)[-*+]\s+", re.MULTILINE)
+HORIZONTAL_RULE_PATTERN = re.compile(r"^[-*_]{3,}\s*$", re.MULTILINE)
+
+# =============================================================================
+# Constants
+# =============================================================================
+
+# Unicode characters for replacements
+BULLET = "•"  # U+2022
+CHECKBOX_CHECKED = "☑"  # U+2611
+CHECKBOX_UNCHECKED = "☐"  # U+2610
+HORIZONTAL_LINE = "─"  # U+2500
+
+# Temporary placeholders to prevent pattern interference
+_BOLD_PLACEHOLDER = "\x00BOLD\x00"
+_ITALIC_PLACEHOLDER = "\x00ITALIC\x00"
+
+
+# =============================================================================
+# Converter class
+# =============================================================================
+
+
+class MrkdwnConverter:
+    """Convert Markdown to Slack mrkdwn format.
+
+    This converter transforms standard CommonMark Markdown into Slack's
+    proprietary mrkdwn format, handling the differences in syntax for
+    bold, italic, links, and other formatting elements.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the converter."""
+        self._in_code_block = False
+        self._table_placeholders: dict[str, str] = {}
+
+    def convert(self, markdown: str) -> str:
+        """Convert Markdown text to Slack mrkdwn format.
+
+        Args:
+            markdown: Input text in Markdown format
+
+        Returns:
+            Text converted to Slack mrkdwn format
+        """
+        if not markdown:
+            return markdown
+
+        # Reset state
+        self._in_code_block = False
+        self._table_placeholders = {}
+
+        text = markdown.strip()
+
+        # Step 1: Extract and placeholder tables (before any conversion)
+        text = self._process_tables(text)
+
+        # Step 2: Process line by line, skipping code blocks
+        lines = text.splitlines()
+        result_lines = []
+
+        for line in lines:
+            # Check for code block markers
+            stripped = line.strip()
+            if stripped.startswith("```"):
+                self._in_code_block = not self._in_code_block
+                result_lines.append(line)
+                continue
+
+            # Skip conversion inside code blocks
+            if self._in_code_block:
+                result_lines.append(line)
+                continue
+
+            # Apply conversion patterns
+            converted_line = self._apply_patterns(line)
+            result_lines.append(converted_line)
+
+        text = "\n".join(result_lines)
+
+        # Step 3: Restore tables
+        for placeholder, table in self._table_placeholders.items():
+            text = text.replace(placeholder, table)
+
+        return text
+
+    def _apply_patterns(self, line: str) -> str:
+        """Apply all conversion patterns to a line.
+
+        Uses placeholders to prevent pattern interference (e.g., bold converted
+        result being matched by italic pattern).
+
+        Args:
+            line: Single line of text
+
+        Returns:
+            Converted line
+        """
+        # Check if line contains inline code - we need to protect it
+        code_segments: dict[str, str] = {}
+        if "`" in line:
+            line, code_segments = self._protect_inline_code(line)
+
+        # Step 1: Convert bold+italic first (uses both asterisks and underscores)
+        line = BOLD_ITALIC_ASTERISKS_PATTERN.sub(
+            lambda m: f"{_BOLD_PLACEHOLDER}{_ITALIC_PLACEHOLDER}{m.group(1)}{_ITALIC_PLACEHOLDER}{_BOLD_PLACEHOLDER}",
+            line,
+        )
+        line = BOLD_ITALIC_UNDERSCORES_PATTERN.sub(
+            lambda m: f"{_BOLD_PLACEHOLDER}{_ITALIC_PLACEHOLDER}{m.group(1)}{_ITALIC_PLACEHOLDER}{_BOLD_PLACEHOLDER}",
+            line,
+        )
+
+        # Step 2: Convert bold (before italic to prevent interference)
+        line = BOLD_ASTERISKS_PATTERN.sub(
+            lambda m: f"{_BOLD_PLACEHOLDER}{m.group(1)}{_BOLD_PLACEHOLDER}",
+            line,
+        )
+        line = BOLD_UNDERSCORES_PATTERN.sub(
+            lambda m: f"{_BOLD_PLACEHOLDER}{m.group(1)}{_BOLD_PLACEHOLDER}",
+            line,
+        )
+
+        # Step 3: Convert italic
+        line = ITALIC_ASTERISKS_PATTERN.sub(
+            lambda m: f"{_ITALIC_PLACEHOLDER}{m.group(1)}{_ITALIC_PLACEHOLDER}",
+            line,
+        )
+        line = ITALIC_UNDERSCORES_PATTERN.sub(
+            lambda m: f"{_ITALIC_PLACEHOLDER}{m.group(1)}{_ITALIC_PLACEHOLDER}",
+            line,
+        )
+
+        # Step 4: Convert other patterns
+        line = STRIKETHROUGH_PATTERN.sub(r"~\1~", line)
+        line = IMAGE_PATTERN.sub(r"<\2>", line)
+        line = LINK_PATTERN.sub(r"<\2|\1>", line)
+        line = TASK_CHECKED_PATTERN.sub(f"\\1{BULLET} {CHECKBOX_CHECKED} ", line)
+        line = TASK_UNCHECKED_PATTERN.sub(f"\\1{BULLET} {CHECKBOX_UNCHECKED} ", line)
+        line = UNORDERED_LIST_PATTERN.sub(f"\\1{BULLET} ", line)
+        line = HORIZONTAL_RULE_PATTERN.sub(HORIZONTAL_LINE * 10, line)
+        line = HEADER_PATTERN.sub(
+            lambda m: f"{_BOLD_PLACEHOLDER}{m.group(1)}{_BOLD_PLACEHOLDER}",
+            line,
+        )
+
+        # Step 5: Replace placeholders with final mrkdwn characters
+        line = line.replace(_BOLD_PLACEHOLDER, "*")
+        line = line.replace(_ITALIC_PLACEHOLDER, "_")
+
+        # Step 6: Restore inline code segments
+        for placeholder, code in code_segments.items():
+            line = line.replace(placeholder, code)
+
+        return line
+
+    def _protect_inline_code(self, line: str) -> tuple[str, dict[str, str]]:
+        """Protect inline code segments with placeholders.
+
+        Args:
+            line: Line containing inline code
+
+        Returns:
+            Tuple of (protected line, mapping of placeholder to code)
+        """
+        code_segments: dict[str, str] = {}
+        counter = 0
+
+        def save_code(match: re.Match[str]) -> str:
+            nonlocal counter
+            placeholder = f"%%CODE_{counter}%%"
+            code_segments[placeholder] = match.group(0)
+            counter += 1
+            return placeholder
+
+        protected_line = INLINE_CODE_PATTERN.sub(save_code, line)
+        return protected_line, code_segments
+
+    def _process_tables(self, text: str) -> str:
+        """Find and wrap markdown tables in code blocks.
+
+        Slack doesn't support markdown tables natively, so we wrap them
+        in code blocks to preserve formatting with monospace display.
+
+        Args:
+            text: Full text content
+
+        Returns:
+            Text with tables wrapped in code blocks via placeholders
+        """
+        lines = text.split("\n")
+        result_lines: list[str] = []
+        i = 0
+        in_code_block = False
+
+        while i < len(lines):
+            line = lines[i]
+
+            # Track code block state
+            if line.strip().startswith("```"):
+                in_code_block = not in_code_block
+                result_lines.append(line)
+                i += 1
+                continue
+
+            # Skip table detection inside code blocks
+            if in_code_block:
+                result_lines.append(line)
+                i += 1
+                continue
+
+            # Check for potential table start
+            if not TABLE_ROW_PATTERN.match(line):
+                result_lines.append(line)
+                i += 1
+                continue
+
+            # Collect consecutive table-like lines
+            table_lines = [line]
+            j = i + 1
+
+            while j < len(lines) and TABLE_ROW_PATTERN.match(lines[j]):
+                table_lines.append(lines[j])
+                j += 1
+
+            # Validate as a proper table (header + separator + data)
+            if len(table_lines) >= 2 and self._is_valid_table(table_lines):
+                # Create wrapped table
+                wrapped = self._wrap_table(table_lines)
+                # Generate unique placeholder
+                placeholder = self._generate_placeholder(wrapped)
+                self._table_placeholders[placeholder] = wrapped
+                result_lines.append(placeholder)
+                i = j
+                continue
+
+            # Not a valid table
+            result_lines.append(line)
+            i += 1
+
+        return "\n".join(result_lines)
+
+    def _is_valid_table(self, table_lines: list[str]) -> bool:
+        """Check if lines form a valid markdown table.
+
+        A valid table has:
+        - A header row
+        - A separator row (dashes with optional alignment colons)
+        - Matching column counts
+
+        Args:
+            table_lines: Lines to validate
+
+        Returns:
+            True if valid markdown table
+        """
+        if len(table_lines) < 2:
+            return False
+
+        header_cells = self._parse_row(table_lines[0])
+        separator_cells = self._parse_row(table_lines[1])
+
+        if len(header_cells) != len(separator_cells):
+            return False
+
+        return self._is_separator_row(separator_cells)
+
+    def _parse_row(self, row: str) -> list[str]:
+        """Parse a markdown table row into cells.
+
+        Args:
+            row: Table row string
+
+        Returns:
+            List of cell contents
+        """
+        stripped = row.strip()
+        if stripped.startswith("|"):
+            stripped = stripped[1:]
+        if stripped.endswith("|"):
+            stripped = stripped[:-1]
+        return [cell.strip() for cell in stripped.split("|")]
+
+    def _is_separator_row(self, cells: list[str]) -> bool:
+        """Check if cells form a separator row.
+
+        Args:
+            cells: Parsed cells from a row
+
+        Returns:
+            True if all cells match separator pattern
+        """
+        return bool(cells) and all(SEPARATOR_CELL_PATTERN.match(cell) for cell in cells)
+
+    def _wrap_table(self, table_lines: list[str]) -> str:
+        """Wrap table lines in a code block.
+
+        Strips markdown formatting from table content for clean display.
+
+        Args:
+            table_lines: Lines of the table
+
+        Returns:
+            Table wrapped in code block
+        """
+        clean_lines = [self._strip_markdown(line) for line in table_lines]
+        return "```\n" + "\n".join(clean_lines) + "\n```"
+
+    def _strip_markdown(self, text: str) -> str:
+        """Strip markdown bold/italic formatting from text.
+
+        Args:
+            text: Text with potential markdown formatting
+
+        Returns:
+            Text with formatting removed
+        """
+        text = BOLD_STRIP_PATTERN.sub(r"\1", text)
+        text = ITALIC_STRIP_PATTERN.sub(r"\1", text)
+        return text
+
+    def _generate_placeholder(self, content: str) -> str:
+        """Generate a unique placeholder for content.
+
+        Args:
+            content: Content to generate placeholder for
+
+        Returns:
+            Unique placeholder string
+        """
+        hash_val = hashlib.md5(content.encode(), usedforsecurity=False).hexdigest()[:8]
+        return f"%%TABLE_{hash_val}%%"
+
+
+def convert(markdown: str) -> str:
+    """Convert Markdown text to Slack mrkdwn format.
+
+    This is a convenience function that creates a converter instance
+    and performs the conversion.
+
+    Args:
+        markdown: Input text in Markdown format
+
+    Returns:
+        Text converted to Slack mrkdwn format
+
+    Example:
+        >>> from md2mrkdwn import convert
+        >>> convert("**Hello** *World*")
+        '*Hello* _World_'
+    """
+    converter = MrkdwnConverter()
+    return converter.convert(markdown)