mdformat_space_control 0.3.0__py3-none-any.whl

mdformat_space_control/__init__.py

@@ -0,0 +1,19 @@
+"""An mdformat plugin for space control: EditorConfig indentation, tight lists, frontmatter spacing, and wikilinks."""
+
+__version__ = "0.3.0"
+
+from .config import (
+    get_current_file,
+    get_indent_config,
+    set_current_file,
+)
+from .plugin import POSTPROCESSORS, RENDERERS, update_mdit
+
+__all__ = [
+    "POSTPROCESSORS",
+    "RENDERERS",
+    "update_mdit",
+    "set_current_file",
+    "get_current_file",
+    "get_indent_config",
+]

mdformat_space_control/config.py

@@ -0,0 +1,122 @@
+"""EditorConfig integration for mdformat-space-control.
+
+This module provides functions to track the current file being formatted
+and retrieve indentation settings from .editorconfig files.
+"""
+
+from contextvars import ContextVar
+from pathlib import Path
+
+import editorconfig
+
+# Thread-safe context variable to track the current file being formatted
+_current_file: ContextVar[Path | None] = ContextVar("current_file", default=None)
+
+
+def set_current_file(filepath: Path | str | None) -> None:
+    """Set the current file being formatted (for editorconfig lookup).
+
+    Args:
+        filepath: Path to the file being formatted, or None to clear.
+    """
+    if filepath is None:
+        _current_file.set(None)
+    else:
+        _current_file.set(Path(filepath).resolve())
+
+
+def get_current_file() -> Path | None:
+    """Get the current file being formatted.
+
+    Returns:
+        Path to the current file, or None if not set.
+    """
+    return _current_file.get()
+
+
+def get_indent_config() -> tuple[str, int] | None:
+    """Get indent configuration from .editorconfig for the current file.
+
+    Looks up .editorconfig settings for the current file. If no file path
+    is explicitly set (via set_current_file), falls back to using the
+    current working directory for editorconfig lookup. This enables CLI
+    usage when running mdformat from a project directory.
+
+    If CWD-based lookup finds no settings and no explicit file was set,
+    falls back to ~/.editorconfig as a final attempt. This handles cases
+    where mdformat is called from applications (like Obsidian plugins)
+    whose working directory is outside the user's HOME tree.
+
+    Returns:
+        Tuple of (indent_style, indent_size) where:
+        - indent_style: "space" or "tab"
+        - indent_size: number of columns per indent level
+        Returns None if no indent config found.
+    """
+    filepath = _current_file.get()
+    explicit_file_set = filepath is not None
+
+    # Fallback to cwd for CLI usage - use a synthetic .md file path
+    # to ensure markdown-specific editorconfig sections are matched
+    if filepath is None:
+        filepath = Path.cwd() / "_.md"
+
+    try:
+        props = editorconfig.get_properties(str(filepath))
+    except editorconfig.EditorConfigError:
+        props = {}
+
+    indent_style = props.get("indent_style")
+    indent_size = props.get("indent_size")
+
+    # Fallback to ~/.editorconfig if no indent config found and no explicit file set
+    # This handles CLI usage from apps whose CWD is outside the user's HOME tree
+    if not indent_style and not indent_size and not explicit_file_set:
+        home_editorconfig = Path.home() / ".editorconfig"
+        if home_editorconfig.exists():
+            try:
+                # Use a synthetic .md file in HOME for the lookup
+                home_props = editorconfig.get_properties(str(Path.home() / "_.md"))
+                indent_style = home_props.get("indent_style")
+                indent_size = home_props.get("indent_size")
+            except editorconfig.EditorConfigError:
+                pass
+
+    # If still neither property is set, return None (passthrough)
+    if not indent_style and not indent_size:
+        return None
+
+    # Default to "space" if only indent_size is set
+    style = indent_style or "space"
+
+    # Parse indent_size, default to 2 if not specified or invalid
+    if indent_size and indent_size.isdigit():
+        size = int(indent_size)
+    elif indent_size == "tab":
+        # Special case: indent_size = tab means use tab_width
+        tab_width = props.get("tab_width")
+        size = int(tab_width) if tab_width and tab_width.isdigit() else 4
+    else:
+        size = 2
+
+    return (style, size)
+
+
+def get_indent_str() -> str | None:
+    """Get the indentation string based on .editorconfig settings.
+
+    Returns:
+        The string to use for one level of indentation:
+        - Tab character if indent_style is "tab"
+        - N spaces if indent_style is "space" (where N is indent_size)
+        Returns None if no indent config found (use default).
+    """
+    config = get_indent_config()
+    if config is None:
+        return None
+
+    style, size = config
+    if style == "tab":
+        return "\t"
+    else:
+        return " " * size

mdformat_space_control/plugin.py

@@ -0,0 +1,400 @@
+"""mdformat-space-control plugin implementation.
+
+Provides custom renderers that combine:
+- EditorConfig-based indentation settings
+- Tight list formatting with multi-paragraph awareness
+- Frontmatter spacing normalization
+- Trailing whitespace removal (outside code blocks)
+- Wikilink preservation ([[link]] and ![[embed]] syntax)
+"""
+
+import re
+from typing import Mapping
+
+from markdown_it import MarkdownIt
+from markdown_it.rules_inline import StateInline
+from mdformat.renderer import RenderContext, RenderTreeNode
+from mdformat.renderer.typing import Postprocess, Render
+from mdformat.renderer._context import (
+    make_render_children,
+    get_list_marker_type,
+)
+
+from mdformat_space_control.config import get_indent_config
+
+
+# Wikilink pattern for Obsidian-style links:
+#   [[page]], [[page|alias]], [[page#heading]], [[page#^blockid]],
+#   [[#heading]], ![[embed]], ![[image.jpg]], etc.
+# Pattern breakdown:
+#   !?                        - optional embed prefix
+#   \[\[                      - opening [[
+#   [^\[\]|]*                 - target (no brackets or pipe)
+#   (?:#[^\[\]|]*)*           - zero or more #heading/#^block sections
+#   (?:\|[^\[\]]+)?           - optional |alias
+#   \]\]                      - closing ]]
+WIKILINK_PATTERN = re.compile(r"!?\[\[([^\[\]|]*(?:#[^\[\]|]*)*)(?:\|[^\[\]]+)?\]\]")
+
+
+def _wikilink_rule(state: StateInline, silent: bool) -> bool:
+    """Parse wikilinks at the current position.
+
+    Matches Obsidian-style wikilinks including:
+    - [[page]] and [[page|alias]]
+    - [[page#heading]] and [[page#^blockid]]
+    - [[#heading]] (same-page links)
+    - ![[embed]] and ![[image.jpg]]
+
+    By running before the link parser, wikilinks inside markdown link text
+    are correctly preserved rather than being extracted and duplicated.
+    """
+    match = WIKILINK_PATTERN.match(state.src, state.pos)
+    if not match:
+        return False
+
+    if not silent:
+        token = state.push("wikilink", "", 0)
+        token.content = match.group(0)
+
+    state.pos = match.end()
+    return True
+
+
+def update_mdit(mdit: MarkdownIt) -> None:
+    """Update the markdown-it parser.
+
+    Adds wikilink parsing support for Obsidian-style [[link]] and ![[embed]]
+    syntax. The rule runs before the link parser to correctly handle wikilinks
+    that appear inside markdown link text.
+    """
+    mdit.inline.ruler.before("link", "wikilink", _wikilink_rule)
+
+
+def has_multiple_paragraphs(list_item_node: RenderTreeNode) -> bool:
+    """Check if a list item has multiple paragraphs."""
+    paragraph_count = 0
+    for child in list_item_node.children:
+        if child.type == "paragraph":
+            paragraph_count += 1
+            if paragraph_count > 1:
+                return True
+    return False
+
+
+def list_has_loose_items(list_node: RenderTreeNode) -> bool:
+    """Check if any item in the list has multiple paragraphs."""
+    for item in list_node.children:
+        if item.type == "list_item" and has_multiple_paragraphs(item):
+            return True
+    return False
+
+
+def _get_indent(default_width: int) -> tuple[str, int]:
+    """Get the indentation string and width based on editorconfig.
+
+    Args:
+        default_width: The default indent width (from marker length).
+
+    Returns:
+        Tuple of (indent_string, indent_width) where:
+        - indent_string: The string to use for indentation
+        - indent_width: The width in columns (for context.indented)
+    """
+    config = get_indent_config()
+    if config is None:
+        # No editorconfig - use default (passthrough behavior)
+        return (" " * default_width, default_width)
+
+    style, size = config
+    if style == "tab":
+        return ("\t", size)  # Tab char, but track column width
+    else:
+        return (" " * size, size)
+
+
+def _render_list_item(node: RenderTreeNode, context: RenderContext) -> str:
+    """Render a list item with appropriate tight/loose formatting.
+
+    For single-paragraph items in tight lists, use tight formatting.
+    For multi-paragraph items, preserve loose formatting.
+    """
+    # Check if this item has multiple paragraphs
+    if has_multiple_paragraphs(node):
+        # Use loose list formatting for multi-paragraph items
+        block_separator = "\n\n"
+    else:
+        # Check if we're in a loose list (any item has multiple paragraphs)
+        parent = node.parent
+        if parent and list_has_loose_items(parent):
+            # Even single paragraph items get loose formatting in a loose list
+            block_separator = "\n\n"
+        else:
+            # Use tight formatting
+            block_separator = "\n"
+
+    text = make_render_children(block_separator)(node, context)
+
+    if not text.strip():
+        return ""
+    return text
+
+
+def _render_bullet_list(node: RenderTreeNode, context: RenderContext) -> str:
+    """Render bullet list with configurable indentation and tight formatting."""
+    marker_type = get_list_marker_type(node)
+    first_line_indent = " "
+    default_indent_width = len(marker_type + first_line_indent)
+
+    # Get configurable indent from editorconfig
+    indent_str, indent_width = _get_indent(default_indent_width)
+
+    # Determine tight/loose based on multi-paragraph items
+    is_loose = list_has_loose_items(node)
+    block_separator = "\n\n" if is_loose else "\n"
+
+    with context.indented(indent_width):
+        text = ""
+        for child_idx, child in enumerate(node.children):
+            list_item = child.render(context)
+            formatted_lines = []
+            line_iterator = iter(list_item.split("\n"))
+            first_line = next(line_iterator, "")
+            formatted_lines.append(
+                f"{marker_type}{first_line_indent}{first_line}"
+                if first_line
+                else marker_type
+            )
+            for line in line_iterator:
+                formatted_lines.append(f"{indent_str}{line}" if line else "")
+            text += "\n".join(formatted_lines)
+            if child_idx < len(node.children) - 1:
+                text += block_separator
+    return text
+
+
+def _render_ordered_list(node: RenderTreeNode, context: RenderContext) -> str:
+    """Render ordered list with configurable indentation and tight formatting."""
+    first_line_indent = " "
+    list_len = len(node.children)
+    starting_number = node.attrs.get("start")
+    if starting_number is None:
+        starting_number = 1
+    assert isinstance(starting_number, int)
+
+    # Determine tight/loose based on multi-paragraph items
+    is_loose = list_has_loose_items(node)
+    block_separator = "\n\n" if is_loose else "\n"
+
+    # Calculate default indent width based on longest marker
+    longest_marker_len = len(
+        str(starting_number + list_len - 1) + "." + first_line_indent
+    )
+
+    # Get configurable indent from editorconfig
+    indent_str, indent_width = _get_indent(longest_marker_len)
+
+    with context.indented(indent_width):
+        text = ""
+        for child_idx, child in enumerate(node.children):
+            list_marker = f"{starting_number + child_idx}."
+
+            list_item = child.render(context)
+            formatted_lines = []
+            line_iterator = iter(list_item.split("\n"))
+            first_line = next(line_iterator, "")
+            formatted_lines.append(
+                f"{list_marker}{first_line_indent}{first_line}"
+                if first_line
+                else list_marker
+            )
+
+            for line in line_iterator:
+                formatted_lines.append(f"{indent_str}{line}" if line else "")
+
+            text += "\n".join(formatted_lines)
+            if child_idx < len(node.children) - 1:
+                text += block_separator
+    return text
+
+
+def _render_wikilink(node: RenderTreeNode, context: RenderContext) -> str:
+    """Render a wikilink token, preserving it unchanged."""
+    return node.content
+
+
+def _render_softbreak(node: RenderTreeNode, context: RenderContext) -> str:
+    """Render soft breaks with terminal backslash.
+
+    Converts soft breaks (plain newlines within paragraphs) to hard breaks
+    (backslash + newline) to preserve visible line-break rendering and avoid
+    relying on trailing whitespace.
+    """
+    return "\\" + "\n"
+
+
+# A mapping from syntax tree node type to a function that renders it.
+# This can be used to overwrite renderer functions of existing syntax
+# or add support for new syntax.
+RENDERERS: Mapping[str, Render] = {
+    "list_item": _render_list_item,
+    "bullet_list": _render_bullet_list,
+    "ordered_list": _render_ordered_list,
+    "wikilink": _render_wikilink,
+    "softbreak": _render_softbreak,
+}
+
+
+def _repair_escaped_links(text: str) -> str:
+    """Repair escaped markdown links that span multiple lines.
+
+    mdformat escapes brackets when links are malformed (contain newlines).
+    This function detects these patterns and reconstructs valid links by:
+    - Removing newlines immediately after \\[
+    - Removing newlines immediately before \\](
+    - Unescaping remaining bracket escapes to form valid links
+
+    Pattern: \\[content\\](url) spanning multiple lines
+    Result: [content](url) with internal newlines preserved
+
+    Handles standard markdown link syntax including image embeds inside links,
+    which is common in web-clipped content.
+    """
+    # Step 1: Remove newlines immediately after escaped opening bracket
+    # \[ followed by one or more newlines → [
+    text = re.sub(r"\\\[\n+", "[", text)
+
+    # Step 2: Remove newlines immediately before escaped closing bracket with URL
+    # one or more newlines followed by \]( → ](
+    text = re.sub(r"\n+\\\]\(", "](", text)
+
+    # Step 3: Unescape \]( that follows non-backslash character
+    # This handles cases where only the opening had newlines
+    text = re.sub(r"(?<=[^\\\n])\\\]\(", "](", text)
+
+    # Step 4: Unescape \[ at start of a repaired link
+    # Pattern: \[ followed by any content ending with ](
+    # This handles cases where only the closing had newlines
+    # Use non-greedy match to find the first ]( after \[
+    text = re.sub(r"\\\[(.+?)\]\(", r"[\1](", text)
+
+    return text
+
+
+def _normalize_frontmatter_spacing(text: str) -> str:
+    """Normalize spacing after YAML frontmatter.
+
+    Removes all blank lines between frontmatter closing delimiter and the
+    first content block, producing tight spacing universally.
+
+    IMPORTANT: Only matches actual frontmatter (document starts with ---)
+    not thematic breaks appearing mid-document.
+    """
+    # Only process if document starts with frontmatter opening delimiter
+    if not text.startswith("---\n"):
+        return text
+
+    # Find the closing delimiter (second --- on its own line)
+    # Pattern: opening --- at start, content, closing --- on its own line
+    frontmatter_match = re.match(r"^---\n.*?\n(---\n)", text, flags=re.DOTALL)
+    if not frontmatter_match:
+        return text
+
+    # Get position after closing delimiter
+    closing_end = frontmatter_match.end(1)
+    before_content = text[:closing_end]
+    after_content = text[closing_end:]
+
+    # Remove all blank lines after frontmatter (tight spacing for any content)
+    after_content = re.sub(r"^\n+", "", after_content)
+
+    return before_content + after_content
+
+
+def _strip_trailing_whitespace(text: str) -> str:
+    """Strip trailing whitespace, preserving code blocks.
+
+    Fenced code blocks (``` or ~~~) preserve trailing whitespace
+    since it may be semantically meaningful in code.
+    """
+    lines = text.split("\n")
+    result = []
+    in_code_block = False
+
+    for line in lines:
+        # Track fenced code block state
+        stripped = line.lstrip()
+        if stripped.startswith("```") or stripped.startswith("~~~"):
+            in_code_block = not in_code_block
+            result.append(line.rstrip())  # Strip fence line itself
+        elif in_code_block:
+            # Preserve trailing whitespace inside code blocks
+            result.append(line)
+        else:
+            # Strip trailing whitespace everywhere else
+            result.append(line.rstrip())
+
+    return "\n".join(result)
+
+
+def _normalize_consecutive_blank_lines(text: str) -> str:
+    """Limit consecutive blank lines to a maximum of 2.
+
+    Collapses runs of 3+ empty lines down to 2 empty lines (3 newlines).
+    Preserves content inside fenced code blocks.
+    """
+    lines = text.split("\n")
+    result = []
+    in_code_block = False
+    consecutive_empty = 0
+
+    for line in lines:
+        # Track code block state
+        stripped = line.strip()
+        if stripped.startswith("```") or stripped.startswith("~~~"):
+            in_code_block = not in_code_block
+
+        if in_code_block:
+            # Preserve everything inside code blocks
+            result.append(line)
+            consecutive_empty = 0
+        elif line == "":
+            consecutive_empty += 1
+            if consecutive_empty <= 2:
+                result.append(line)
+            # else: skip this empty line (collapse)
+        else:
+            consecutive_empty = 0
+            result.append(line)
+
+    return "\n".join(result)
+
+
+def _postprocess_root(text: str, node: RenderTreeNode, context: RenderContext) -> str:
+    """Combined postprocessor for all space control features.
+
+    Applies the following transformations in order:
+    1. Frontmatter spacing normalization
+    2. Escaped link repair
+    3. Consecutive blank line normalization
+    4. Trailing whitespace removal
+    """
+    # 1. Frontmatter spacing
+    text = _normalize_frontmatter_spacing(text)
+
+    # 2. Repair escaped links (before trailing whitespace removal)
+    text = _repair_escaped_links(text)
+
+    # 3. Limit consecutive blank lines to 2
+    text = _normalize_consecutive_blank_lines(text)
+
+    # 4. Trailing whitespace removal
+    text = _strip_trailing_whitespace(text)
+
+    return text
+
+
+# A mapping from syntax tree node type to a postprocessing function.
+# Postprocessors run after rendering and can modify the output text.
+POSTPROCESSORS: Mapping[str, Postprocess] = {
+    "root": _postprocess_root,
+}

mdformat_space_control-0.3.0.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: mdformat_space_control
+Version: 0.3.0
+Summary: An mdformat plugin for space control: EditorConfig indentation, tight lists, frontmatter spacing, and wikilinks.
+Keywords: mdformat,markdown,formatter,editorconfig,indentation,lists,frontmatter,wikilink,obsidian
+Author-email: Joseph Monaco <joe@selfmotion.net>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+License-File: LICENSE
+Requires-Dist: mdformat>=0.7.0
+Requires-Dist: editorconfig>=0.12.0
+Requires-Dist: pytest>=7.0 ; extra == "test"
+Requires-Dist: pytest-cov>=4.0 ; extra == "test"
+Requires-Dist: mdformat-frontmatter>=2.0.0 ; extra == "test"
+Requires-Dist: mdformat-simple-breaks>=0.1.0 ; extra == "test"
+Project-URL: Homepage, https://github.com/jdmonaco/mdformat-space-control
+Provides-Extra: test
+
+# mdformat-space-control
+
+[![Build Status][ci-badge]][ci-link]
+[![PyPI version][pypi-badge]][pypi-link]
+
+An [mdformat](https://github.com/executablebooks/mdformat) plugin that provides unified control over Markdown spacing:
+
+- **EditorConfig support**: Configure list indentation via `.editorconfig` files
+- **Tight list formatting**: Automatically removes unnecessary blank lines between list items
+- **Frontmatter spacing**: Normalizes spacing after YAML frontmatter (works with [mdformat-frontmatter](https://github.com/butler54/mdformat-frontmatter))
+- **Consecutive blank line normalization**: Limits runs of 3+ empty lines to a maximum of 2
+- **Trailing whitespace removal**: Strips trailing whitespace outside code blocks
+- **Escaped link repair**: Fixes malformed multi-line links from web-clipped content
+- **Wikilink preservation**: Handles Obsidian-style `[[links]]`, `[[links|aliases]]`, `[[page#heading]]`, `[[page#^blockid]]`, and `![[embeds]]`
+
+## Installation
+
+```bash
+pip install mdformat-space-control
+```
+
+Or with [pipx](https://pipx.pypa.io/) for command-line usage:
+
+```bash
+pipx install mdformat
+pipx inject mdformat mdformat-space-control
+```
+
+## Usage
+
+After installation, mdformat will automatically use this plugin:
+
+```bash
+mdformat your-file.md
+```
+
+### EditorConfig Support
+
+Create an `.editorconfig` file in your project:
+
+```ini
+# .editorconfig
+root = true
+
+[*.md]
+indent_style = space
+indent_size = 4
+```
+
+Nested lists will use the configured indentation:
+
+**Before:**
+```markdown
+- Item 1
+  - Nested item
+- Item 2
+```
+
+**After (with 4-space indent):**
+```markdown
+- Item 1
+    - Nested item
+- Item 2
+```
+
+### Tight List Formatting
+
+Lists with single-paragraph items are automatically formatted as tight lists:
+
+**Before:**
+```markdown
+- Item 1
+
+- Item 2
+
+- Item 3
+```
+
+**After:**
+```markdown
+- Item 1
+- Item 2
+- Item 3
+```
+
+Multi-paragraph items preserve loose formatting:
+
+```markdown
+- First item with multiple paragraphs
+
+  Second paragraph of first item
+
+- Second item
+```
+
+### Frontmatter Spacing
+
+When used with [mdformat-frontmatter](https://github.com/butler54/mdformat-frontmatter), this plugin removes blank lines between the frontmatter closing delimiter and the first content block:
+
+**Before:**
+```markdown
+---
+title: My Document
+---
+
+
+# Introduction
+```
+
+**After:**
+```markdown
+---
+title: My Document
+---
+# Introduction
+```
+
+Install both plugins for this feature:
+
+```bash
+pip install mdformat-space-control mdformat-frontmatter
+```
+
+### EditorConfig Properties
+
+| Property | Status | Notes |
+|----------|--------|-------|
+| `indent_style` | Supported | `space` or `tab` for list indentation |
+| `indent_size` | Supported | Number of spaces per indent level |
+| `tab_width` | Supported | Used when `indent_size = tab` |
+
+### Python API
+
+When using the Python API, you can set the file context for EditorConfig lookup:
+
+```python
+import mdformat
+from mdformat_space_control import set_current_file
+
+set_current_file("/path/to/your/file.md")
+try:
+    result = mdformat.text(markdown_text, extensions={"space_control"})
+finally:
+    set_current_file(None)
+```
+
+### Wikilink Preservation
+
+Obsidian-style wikilinks are preserved during formatting:
+
+```markdown
+Link to [[another note]] or [[note|with alias]].
+Embed an image: ![[photo.jpg]]
+Link to heading: [[note#section]]
+Block reference: [[note#^blockid]]
+```
+
+Wikilinks inside markdown link text are correctly handled without duplication:
+
+```markdown
+[![[image.jpg]]](http://example.com)
+```
+
+## Compatible Plugins
+
+This plugin is tested to work alongside:
+
+- [mdformat-frontmatter](https://github.com/butler54/mdformat-frontmatter) - YAML frontmatter parsing
+- [mdformat-simple-breaks](https://github.com/csala/mdformat-simple-breaks) - Normalizes thematic breaks to `---`
+
+For formatting files in an **Obsidian vault**, installing `mdformat-frontmatter` alongside this plugin is recommended:
+
+```bash
+pip install mdformat-space-control mdformat-frontmatter
+```
+
+Note: Wikilink support is built-in; `mdformat-wikilink` is not needed.
+
+## Development
+
+```bash
+# Install dependencies
+uv sync
+
+# Run tests
+uv run python -m pytest
+
+# Run with coverage
+uv run python -m pytest --cov=mdformat_space_control
+```
+
+## License
+
+MIT - see LICENSE file for details.
+
+[ci-badge]: https://github.com/jdmonaco/mdformat-space-control/actions/workflows/tests.yml/badge.svg?branch=main
+[ci-link]: https://github.com/jdmonaco/mdformat-space-control/actions/workflows/tests.yml
+[pypi-badge]: https://img.shields.io/pypi/v/mdformat-space-control.svg
+[pypi-link]: https://pypi.org/project/mdformat-space-control
+

mdformat_space_control-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mdformat_space_control/__init__.py,sha256=-rXQZCz7uYMbIv5K8sh9JCZ7icgiJGvvJtYcSGUYyYU,439
+mdformat_space_control/config.py,sha256=b0cEeMeoBwrcYdoESTR-0A4S6oEqozXT2WbwXlCyBr4,4237
+mdformat_space_control/plugin.py,sha256=Fv7U0UNUKgsuFpRSjAoxboIiTDlEgoaG2da4rHeIJ5Y,13950
+mdformat_space_control-0.3.0.dist-info/entry_points.txt,sha256=GMA7LGi700M9BbMR4QlCa2ARh4k4gipa4mbU4ztdltE,66
+mdformat_space_control-0.3.0.dist-info/licenses/LICENSE,sha256=-voxTd2luDRUXIFkSXQRQGL3cHzC9AnnJkv3LJrla3o,1073
+mdformat_space_control-0.3.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+mdformat_space_control-0.3.0.dist-info/METADATA,sha256=zaY9fqus7YWKsEL5bZ_wv5eu3ZckQe2UrQwwWrhR0o0,5916
+mdformat_space_control-0.3.0.dist-info/RECORD,,

mdformat_space_control-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mdformat_space_control-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[mdformat.parser_extension]
+space_control=mdformat_space_control
+

mdformat_space_control-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Executable Books
+
+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.