pymdownx-mahjong 1.0.0__tar.gz → 1.2.0__tar.gz

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: pymdownx-mahjong
-Version: 1.0.0
+Version: 1.2.0
 Summary: Python Markdown extension to render and stylize Mahjong tiles.
 Project-URL: Homepage, https://github.com/tylernguyen/pymdownx-mahjong
-Project-URL: Documentation, https://github.com/tylernguyen/pymdownx-mahjong
+Project-URL: Documentation, https://tylernguyen.github.io/pymdownx-mahjong/
 Project-URL: Repository, https://github.com/tylernguyen/pymdownx-mahjong
 Project-URL: Issues, https://github.com/tylernguyen/pymdownx-mahjong/issues
 Author: Tyler Nguyen
@@ -35,9 +35,15 @@ Requires-Dist: mkdocs-material>=9.0; extra == 'mkdocs'
 Requires-Dist: mkdocs>=1.4; extra == 'mkdocs'
 Description-Content-Type: text/markdown
 
+![PyPI - Version](https://img.shields.io/pypi/v/pymdownx-mahjong)
+
 # PyMdown Mahjong
 
-Extensions for [Python Markdown](https://python-markdown.github.io) that aids writing Mahjong content
+[Python Markdown](https://python-markdown.github.io) extension to render and stylize Mahjong tiles. Designed for use with [MkDocs](https://github.com/mkdocs/mkdocs) and [Zensical](https://github.com/zensical/zensical).
+
+## Demo and Documentation
+
+Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
 
 ## License
 

pymdownx_mahjong-1.2.0/README.md

@@ -0,0 +1,13 @@
+![PyPI - Version](https://img.shields.io/pypi/v/pymdownx-mahjong)
+
+# PyMdown Mahjong
+
+[Python Markdown](https://python-markdown.github.io) extension to render and stylize Mahjong tiles. Designed for use with [MkDocs](https://github.com/mkdocs/mkdocs) and [Zensical](https://github.com/zensical/zensical).
+
+## Demo and Documentation
+
+Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
+
+## License
+
+License is Creative Commons Attribution-NonCommercial 4.0 International.  See [LICENSE](https://github.com/tylernguyen/pymdownx-mahjong/blob/main/LICENSE).

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/__init__.py

@@ -4,7 +4,7 @@ from .extension import MahjongExtension, makeExtension
 from .inline import INLINE_TILE_PATTERN, MahjongInlineProcessor
 from .parser import Hand, MahjongParser, Meld, Tile
 from .renderer import MahjongRenderer
-from .superfences import superfences_formatter, superfences_validator
+from .superfences import configure_superfences, superfences_formatter, superfences_validator
 
 __all__ = [
     "MahjongExtension",
@@ -18,6 +18,7 @@ __all__ = [
     "Hand",
     "superfences_formatter",
     "superfences_validator",
+    "configure_superfences",
 ]
 
-__version__ = "1.0.0"
+__version__ = "1.2.0"

pymdownx_mahjong-1.2.0/pymdownx_mahjong/assets/README.md

@@ -0,0 +1,3 @@
+Original assets by https://github.com/FluffyStuff/riichi-mahjong-tiles, available in the public domain.
+
+Some assets have been recolored, tweaks, minified, or otherwise modified.

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/css/mahjong.css

@@ -23,7 +23,7 @@
     --mahjong-error-border: #dc2626;
     --mahjong-error-color: #fca5a5;
     --mahjong-tile-bg: #1e1e1e;
-    --mahjong-tile-border: #9a9a8a;
+    --mahjong-tile-border: #47473e;
     --mahjong-tile-shadow: rgba(0, 0, 0, 0.3);
 }
 
@@ -48,7 +48,7 @@
     display: contents;
 }
 
-/* Main container */
+/* NOTE Main container */
 .mahjong-hand {
     display: block;
     margin: 1em 0;
@@ -58,24 +58,24 @@
     border-radius: 4px;
 }
 
-/* Override MkDocs Material theme figure margins */
+/* NOTE Override MkDocs Material/Zensical theme figure margins */
 .md-typeset .mahjong-hand {
     margin-left: 1rem;
 }
 
-/* Hand row - contains left (tiles/melds), draw, and right (dora) sections */
+/* NOTE Hand row - contains left (tiles/melds), draw, and right (dora) sections */
 .mahjong-hand-row {
     display: flex;
     flex-wrap: nowrap;
     align-items: flex-end;
 }
 
-/* Left section - closed tiles and melds */
+/* NOTE Left section - closed tiles and melds */
 .mahjong-hand-left {
     flex: 0 0 auto;
 }
 
-/* Draw tile section - separated from main hand */
+/* NOTE Draw tile section */
 .mahjong-hand-draw {
     flex: 0 0 auto;
     margin-left: calc(var(--mahjong-meld-gap) * 0.75);
@@ -96,13 +96,13 @@
     pointer-events: none;
 }
 
-/* Melds section - after draw tile */
+/* NOTE Melds section - after draw tile */
 .mahjong-hand-melds {
     flex: 0 0 auto;
     margin-left: calc(var(--mahjong-meld-gap) * 0.75);
 }
 
-/* Tiles container - flexbox layout */
+/* NOTE Tiles container - flexbox layout */
 .mahjong-tiles {
     display: flex;
     flex-wrap: wrap;
@@ -110,7 +110,7 @@
     gap: var(--mahjong-tile-gap);
 }
 
-/* Individual tile - styled like physical riichi tiles */
+/* NOTE Individual tile - styled like physical riichi tiles */
 .mahjong-tile {
     display: inline-flex;
     align-items: center;
@@ -122,9 +122,6 @@
     background: var(--mahjong-tile-bg);
     border: 2px solid var(--mahjong-tile-border);
     border-radius: 6px;
-    box-shadow:
-        1px 2px 3px var(--mahjong-tile-shadow),
-        inset 0 1px 0 rgba(255, 255, 255, 0.3);
     padding: 2px;
     box-sizing: border-box;
     position: relative;
@@ -144,6 +141,8 @@
 /* Rotated tile (called from another player) */
 .mahjong-tile-rotated {
     transform: rotate(90deg);
+    will-change: transform;
+    backface-visibility: hidden;
     margin-left: calc(var(--mahjong-tile-gap) * 6);
     margin-right: calc(var(--mahjong-tile-gap) * 6);
     position: relative;

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/extension.py

@@ -19,6 +19,15 @@ if TYPE_CHECKING:
     from markdown.blockparser import BlockParser
 
 
+def _to_bool(value: Any) -> bool:
+    """Convert a value to boolean, handling string 'true'/'false'."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
+
+
 class MahjongBlockProcessor(BlockProcessor):
     """Block processor that handles ```mahjong fenced code blocks.
 
@@ -43,10 +52,9 @@ class MahjongBlockProcessor(BlockProcessor):
         self.mj_parser = MahjongParser()
         self.renderer = MahjongRenderer(
             theme=config.get("theme", "light"),
-            css_class=config.get("css_class", "mahjong-hand"),
-            show_labels=config.get("show_labels", True),
-            inline_svg=config.get("inline_svg", True),
+            inline_svg=_to_bool(config.get("inline_svg", True)),
             assets_path=config.get("assets_path"),
+            closed_kan_style=config.get("closed_kan_style", "outer"),
         )
 
     def test(self, parent: etree.Element, block: str) -> bool:
@@ -158,13 +166,13 @@ class MahjongExtension(markdown.Extension):
             **kwargs: Configuration options
         """
         # Define configuration options with defaults
+        # Note: Use strings for boolean defaults for YAML compatibility
         self.config = {
             "theme": ["auto", "Color theme: 'light', 'dark', or 'auto'"],
-            "css_class": ["mahjong-hand", "CSS class for container"],
-            "show_labels": [True, "Show tile names as title attributes"],
-            "inline_svg": [True, "Inline SVG content vs img tags"],
+            "inline_svg": ["true", "Inline SVG content vs img tags"],
             "assets_path": ["", "Custom path to SVG assets"],
-            "enable_inline": [True, "Enable inline tile syntax (:1m:)"],
+            "enable_inline": ["true", "Enable inline tile syntax (:1m:)"],
+            "closed_kan_style": ["outer", "Closed kan style: 'outer' or 'inner'"],
         }
         super().__init__(**kwargs)
 
@@ -184,7 +192,7 @@ class MahjongExtension(markdown.Extension):
 
         # Register inline processor if enabled
         # Priority 76 to run before pymdownx.emoji (which uses 75)
-        if config.get("enable_inline", True):
+        if _to_bool(config.get("enable_inline", True)):
             inline_processor = MahjongInlineProcessor(INLINE_TILE_PATTERN, md, config)
             md.inlinePatterns.register(inline_processor, "mahjong_inline", 76)
 

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/inline.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Final
 
 from markdown.inlinepatterns import InlineProcessor
 
@@ -17,7 +17,16 @@ if TYPE_CHECKING:
 # Pattern matches :123m:, :1z:, :0m: (red dora), etc.
 # Must be valid MPSZ: one or more groups of digits followed by m/p/s/z
 # Examples: :1m:, :123p:, :5z:, :0s:, :123m456p:
-INLINE_TILE_PATTERN = r":([0-9]+[mpsz])+:"
+INLINE_TILE_PATTERN: Final[str] = r":([0-9]+[mpsz])+:"
+
+
+def _to_bool(value: Any) -> bool:
+    """Convert a value to boolean, handling string 'true'/'false'."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
 
 
 class MahjongInlineProcessor(InlineProcessor):
@@ -40,10 +49,9 @@ class MahjongInlineProcessor(InlineProcessor):
         self.parser = MahjongParser()
         self.renderer = MahjongRenderer(
             theme=config.get("theme", "auto"),
-            css_class="mahjong-inline",
-            show_labels=config.get("show_labels", True),
-            inline_svg=config.get("inline_svg", True),
+            inline_svg=_to_bool(config.get("inline_svg", True)),
             assets_path=config.get("assets_path"),
+            css_class="mahjong-inline",
         )
 
     def handleMatch(self, m: re.Match, data: str) -> tuple[str | None, int | None, int | None]:

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/parser.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import re
+from collections import Counter
 from dataclasses import dataclass, field
 from enum import Enum
+from typing import Final, Pattern
 
 from .tiles import TileInfo, get_tile_info, is_valid_tile
 
@@ -127,11 +129,11 @@ class MahjongParser:
     """
 
     # Pattern for a group of numbers followed by a suit
-    TILE_GROUP_PATTERN = re.compile(r"([0-9]+)([mpsz])")
+    TILE_GROUP_PATTERN: Final[Pattern[str]] = re.compile(r"([0-9]+)([mpsz])")
 
     # Pattern for melds: (tiles<) or [tiles] with optional source marker inside brackets
     # For added kan, use + to mark the added tile: (111+1m<)
-    MELD_PATTERN = re.compile(r"(\[|\()([0-9]+)(\+)?([0-9])?([mpsz])([<^>])?(\]|\))")
+    MELD_PATTERN: Final[Pattern[str]] = re.compile(r"(\[|\()([0-9]+)(\+)?([0-9])?([mpsz])([<^>])?(\]|\))")
 
     def __init__(self) -> None:
         self.errors: list[str] = []
@@ -163,6 +165,9 @@ class MahjongParser:
         # Parse closed tiles
         hand.closed_tiles = self._parse_tiles(closed_part)
 
+        # Validate tile counts (max 4 of each tile type)
+        self._validate_tile_counts(hand)
+
         if self.errors:
             raise ParseError("; ".join(self.errors))
 
@@ -336,6 +341,32 @@ class MahjongParser:
 
         return numbers[1] == numbers[0] + 1 and numbers[2] == numbers[1] + 1
 
+    def _validate_tile_counts(self, hand: Hand) -> None:
+        """Validate that no tile appears more than 4 times.
+
+        In Mahjong, there are exactly 4 copies of each tile type.
+        Having more than 4 of the same tile is invalid.
+
+        Args:
+            hand: The Hand object to validate
+        """
+        # Count all tiles including melds
+        # Note: Red 5 (0) and regular 5 are different tiles, so we count them separately
+        all_tiles = list(hand.closed_tiles)
+        for meld in hand.melds:
+            all_tiles.extend(meld.tiles)
+        if hand.draw_tile:
+            all_tiles.append(hand.draw_tile)
+
+        counts = Counter((t.suit, t.number) for t in all_tiles)
+
+        for (suit, number), count in counts.items():
+            if count > 4:
+                tile_notation = f"{number}{suit}"
+                self.errors.append(
+                    f"Invalid tile count: {tile_notation} appears {count} times (max 4)"
+                )
+
 
 def parse_hand(notation: str) -> Hand:
     """Convenience function to parse a hand notation.

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/renderer.py

@@ -2,23 +2,47 @@
 
 from __future__ import annotations
 
+import functools
 import html
 import importlib.resources
 import re
 from pathlib import Path
+from typing import Final, Pattern
 
 from .parser import Hand, Meld, MeldType, Tile
 from .tiles import TileInfo, get_special_tile
 
 # Pre-compiled regex patterns for SVG processing
-_RE_XML_DECL = re.compile(r"<\?xml[^?]*\?>")
-_RE_SODIPODI_SELF = re.compile(r"<sodipodi:namedview[^>]*/>")
-_RE_SODIPODI_FULL = re.compile(r"<sodipodi:namedview[^>]*>.*?</sodipodi:namedview>", re.DOTALL)
-_RE_METADATA = re.compile(r"<metadata[^>]*>.*?</metadata>", re.DOTALL)
-_RE_WIDTH = re.compile(r'width="[^"]*"')
-_RE_HEIGHT = re.compile(r'height="[^"]*"')
+_RE_XML_DECL: Final[Pattern[str]] = re.compile(r"<\?xml[^?]*\?>")
+_RE_SODIPODI_SELF: Final[Pattern[str]] = re.compile(r"<sodipodi:namedview[^>]*/>")
+_RE_SODIPODI_FULL: Final[Pattern[str]] = re.compile(r"<sodipodi:namedview[^>]*>.*?</sodipodi:namedview>", re.DOTALL)
+_RE_METADATA: Final[Pattern[str]] = re.compile(r"<metadata[^>]*>.*?</metadata>", re.DOTALL)
+_RE_WIDTH: Final[Pattern[str]] = re.compile(r'width="[^"]*"')
+_RE_HEIGHT: Final[Pattern[str]] = re.compile(r'height="[^"]*"')
 # Pattern to find IDs in SVGs
-_RE_ID = re.compile(r'id="([^"]+)"')
+_RE_ID: Final[Pattern[str]] = re.compile(r'id="([^"]+)"')
+
+
+@functools.lru_cache(maxsize=128)
+def _load_svg_from_package(asset_name: str, theme: str) -> str:
+    """Load SVG content from package resources with caching.
+
+    This is a module-level cached function to avoid repeated file I/O
+    for the same tile assets across multiple renderer instances.
+
+    Args:
+        asset_name: Name of the asset (e.g., '1m', 'back')
+        theme: Theme to load ('light' or 'dark')
+
+    Returns:
+        Raw SVG content string
+
+    Raises:
+        FileNotFoundError: If the asset doesn't exist
+    """
+    assets = importlib.resources.files("pymdownx_mahjong") / "assets" / theme
+    svg_file = assets / f"{asset_name}.svg"
+    return svg_file.read_text(encoding="utf-8")
 
 
 class MahjongRenderer:
@@ -26,9 +50,8 @@ class MahjongRenderer:
 
     Configuration options:
         theme: 'light', 'dark', or 'auto'
-        css_class: CSS class for the container
-        show_labels: Whether to show tile names as titles
-        inline_svg: Whether to inline SVG or use img tags
+        closed_kan_style: 'outer' (default) or 'inner'
+        inline_svg: Whether to inline SVG content (vs using img tags)
     """
 
     DEFAULT_TILE_WIDTH = 45
@@ -39,19 +62,21 @@ class MahjongRenderer:
     def __init__(
         self,
         theme: str = "light",
-        css_class: str = "mahjong-hand",
-        show_labels: bool = True,
         inline_svg: bool = True,
         assets_path: str | Path | None = None,
+        closed_kan_style: str = "outer",
+        css_class: str = "mahjong-hand",
     ) -> None:
         """Initialize the renderer.
 
         Args:
             theme: Color theme ('light', 'dark', or 'auto')
-            css_class: CSS class for the container element
-            show_labels: Show tile names as title attributes
             inline_svg: Inline SVG content vs img tags
             assets_path: Custom path to SVG assets
+            closed_kan_style: Style for closed kan back tiles:
+                'outer' (default) - back tiles on edges (back, front, front, back)
+                'inner' - back tiles in middle (front, back, back, front)
+            css_class: CSS class for container (internal use)
         """
         self.theme = theme
         self.tile_width = self.DEFAULT_TILE_WIDTH
@@ -59,10 +84,9 @@ class MahjongRenderer:
         self.tile_gap = self.DEFAULT_TILE_GAP
         self.meld_gap = self.DEFAULT_MELD_GAP
         self.css_class = css_class
-        self.show_labels = show_labels
         self.inline_svg = inline_svg
         self.assets_path = Path(assets_path) if assets_path else None
-        self._svg_cache: dict[tuple[str, str], str] = {}
+        self.closed_kan_style = closed_kan_style
         self._svg_id_counter = 0
 
     def render(
@@ -186,7 +210,7 @@ class MahjongRenderer:
             classes.append("mahjong-tile-added")
 
         class_str = " ".join(classes)
-        title_attr = f' title="{info.display_name}"' if self.show_labels else ""
+        title_attr = f' title="{info.display_name}"'
 
         if self.inline_svg:
             svg_content = self._get_themed_svg_content(info)
@@ -248,9 +272,18 @@ class MahjongRenderer:
                 parts.append(self._render_tile(meld.tiles[2]))
         else:
             for i, tile in enumerate(meld.tiles):
-                # For closed kan, show back tiles for middle two
-                if meld.meld_type == MeldType.KAN_CLOSED and i in (1, 2):
-                    parts.append(self._render_back_tile())
+                # For closed kan, show back tiles based on style setting
+                if meld.meld_type == MeldType.KAN_CLOSED:
+                    if self.closed_kan_style == "inner":
+                        # 'inner': back tiles in middle: front, back, back, front
+                        is_back = i in (1, 2)
+                    else:
+                        # Default 'outer': back tiles on edges: back, front, front, back
+                        is_back = i in (0, 3)
+                    if is_back:
+                        parts.append(self._render_back_tile())
+                    else:
+                        parts.append(self._render_tile(tile))
                 else:
                     parts.append(self._render_tile(tile))
 
@@ -290,17 +323,12 @@ class MahjongRenderer:
             SVG content string with unique IDs
         """
         theme = theme or (self.theme if self.theme != "auto" else "light")
-        cache_key = (theme, info.asset_name)
 
-        # Cache raw loaded SVG content (before ID uniquification)
-        if cache_key not in self._svg_cache:
-            svg_content = self._load_svg(info, theme)
-            # Process but don't add unique IDs yet - cache the base processed version
-            svg_content = self._process_svg(svg_content, unique_prefix=None)
-            self._svg_cache[cache_key] = svg_content
+        # Load and process SVG (package assets use module-level LRU cache)
+        svg_content = self._load_svg(info, theme)
+        svg_content = self._process_svg(svg_content)
 
-        # Get cached SVG and make IDs unique for this instance
-        svg_content = self._svg_cache[cache_key]
+        # Make IDs unique for this instance
         self._svg_id_counter += 1
         return self._make_ids_unique(svg_content, f"mj{self._svg_id_counter}_")
 
@@ -342,32 +370,28 @@ class MahjongRenderer:
         """
         theme = theme or (self.theme if self.theme != "auto" else "light")
 
-        # Try custom assets path first
+        # Try custom assets path first (not cached since it's user-specific)
         if self.assets_path:
             svg_path = self.assets_path / theme / f"{info.asset_name}.svg"
             if svg_path.exists():
                 return svg_path.read_text(encoding="utf-8")
 
-        # Fall back to package assets
+        # Fall back to package assets (uses module-level LRU cache)
         try:
-            assets = importlib.resources.files("pymdownx_mahjong") / "assets" / theme
-            svg_file = assets / f"{info.asset_name}.svg"
-            return svg_file.read_text(encoding="utf-8")
+            return _load_svg_from_package(info.asset_name, theme)
         except (FileNotFoundError, TypeError):
             # Return a placeholder SVG
             return self._placeholder_svg(info)
 
-    def _process_svg(self, svg_content: str, unique_prefix: str | None = None) -> str:
+    def _process_svg(self, svg_content: str) -> str:
         """Process SVG content for inline use.
 
         - Removes XML declaration
         - Removes unnecessary metadata
         - Adds sizing attributes
-        - Makes IDs unique to avoid conflicts when multiple SVGs are on the same page
 
         Args:
             svg_content: Raw SVG content
-            unique_prefix: Optional prefix to make IDs unique
 
         Returns:
             Processed SVG content
@@ -384,10 +408,6 @@ class MahjongRenderer:
         svg_content = _RE_WIDTH.sub(f'width="{self.tile_width}"', svg_content, count=1)
         svg_content = _RE_HEIGHT.sub(f'height="{self.tile_height}"', svg_content, count=1)
 
-        # Make IDs unique if prefix is provided
-        if unique_prefix:
-            svg_content = self._make_ids_unique(svg_content, unique_prefix)
-
         return svg_content.strip()
 
     def _make_ids_unique(self, svg_content: str, prefix: str) -> str:

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/superfences.py

@@ -17,20 +17,32 @@ class _SuperfencesState:
     """Encapsulates global state for superfences integration.
 
     Uses lazy initialization to create parser/renderer on first use.
+    Allows configuration via configure() method.
     """
 
     def __init__(self) -> None:
         self._renderer: MahjongRenderer | None = None
         self._parser: MahjongParser | None = None
+        self._config: dict[str, Any] = {}
+
+    def configure(self, **kwargs: Any) -> None:
+        """Configure the superfences state.
+
+        Args:
+            **kwargs: Configuration options (theme, closed_kan_style, etc.)
+        """
+        self._config.update(kwargs)
+        # Reset renderer to apply new config
+        self._renderer = None
 
     @property
     def renderer(self) -> MahjongRenderer:
         """Get or create the renderer instance."""
         if self._renderer is None:
             self._renderer = MahjongRenderer(
-                theme="auto",
-                show_labels=True,
-                inline_svg=True,
+                theme=self._config.get("theme", "auto"),
+                inline_svg=self._config.get("inline_svg", True),
+                closed_kan_style=self._config.get("closed_kan_style", "outer"),
             )
         return self._renderer
 
@@ -46,6 +58,24 @@ class _SuperfencesState:
 _state = _SuperfencesState()
 
 
+def configure_superfences(**kwargs: Any) -> None:
+    """Configure the superfences integration.
+
+    Call this before using superfences to set options like closed_kan_style.
+
+    Example:
+        from pymdownx_mahjong import configure_superfences
+        configure_superfences(closed_kan_style='outer')
+
+    Args:
+        **kwargs: Configuration options
+            - theme: 'light', 'dark', or 'auto'
+            - closed_kan_style: 'outer' or 'inner'
+            - inline_svg: bool
+    """
+    _state.configure(**kwargs)
+
+
 def superfences_validator(
     language: str,
     inputs: dict[str, str],
@@ -65,6 +95,14 @@ def superfences_validator(
     Returns:
         True if this is a valid mahjong fence
     """
+    # Try to get config from the markdown instance's extension
+    if hasattr(md, 'registeredExtensions'):
+        for ext in md.registeredExtensions:
+            if hasattr(ext, 'config') and 'closed_kan_style' in ext.config:
+                config = {key: ext.getConfig(key) for key in ext.config}
+                _state.configure(**config)
+                break
+
     return language == "mahjong"
 
 

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/tiles.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import NamedTuple
+from typing import Final, NamedTuple
 
 
 class TileInfo(NamedTuple):
@@ -12,7 +12,7 @@ class TileInfo(NamedTuple):
     display_name: str
 
 
-TILE_DATABASE: dict[tuple[str, int], TileInfo] = {
+TILE_DATABASE: Final[dict[tuple[str, int], TileInfo]] = {
     # Manzu
     ("m", 1): TileInfo("1m", "1 Man"),
     ("m", 2): TileInfo("2m", "2 Man"),
@@ -57,7 +57,7 @@ TILE_DATABASE: dict[tuple[str, int], TileInfo] = {
     ("z", 7): TileInfo("7z", "Red Dragon"),
 }
 
-SPECIAL_TILES: dict[str, TileInfo] = {
+SPECIAL_TILES: Final[dict[str, TileInfo]] = {
     "back": TileInfo("back", "Face Down"),
     "blank": TileInfo("blank", "Blank"),
     "front": TileInfo("front", "Front"),

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pymdownx-mahjong"
-version = "1.0.0"
+version = "1.2.0"
 description = "Python Markdown extension to render and stylize Mahjong tiles."
 readme = "README.md"
 license = "CC-BY-NC-4.0"
@@ -52,7 +52,7 @@ dev = [
 
 [project.urls]
 Homepage = "https://github.com/tylernguyen/pymdownx-mahjong"
-Documentation = "https://github.com/tylernguyen/pymdownx-mahjong"
+Documentation = "https://tylernguyen.github.io/pymdownx-mahjong/"
 Repository = "https://github.com/tylernguyen/pymdownx-mahjong"
 Issues = "https://github.com/tylernguyen/pymdownx-mahjong/issues"