PyPI - Micron2HTML - Versions diffs - 1.0.5__py3-none-any.whl - Mend

Micron2HTML 1.0.5__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

micron2html/RobotoMonoNerdFont-Regular.ttf +0 -0
micron2html/__init__.py +4 -0
micron2html/__main__.py +3 -0
micron2html/cli.py +107 -0
micron2html/converter.py +703 -0
micron2html/micron-meshchat.css +245 -0
micron2html-1.0.5.dist-info/METADATA +227 -0
micron2html-1.0.5.dist-info/RECORD +12 -0
micron2html-1.0.5.dist-info/WHEEL +5 -0
micron2html-1.0.5.dist-info/entry_points.txt +2 -0
micron2html-1.0.5.dist-info/licenses/LICENSE +21 -0
micron2html-1.0.5.dist-info/top_level.txt +1 -0

micron2html/RobotoMonoNerdFont-Regular.ttf ADDED Viewed

Binary file

micron2html/__init__.py ADDED Viewed

@@ -0,0 +1,4 @@
+from .converter import MicronConverter, default_url_resolver, UrlResolver
+__all__ = ["MicronConverter", "default_url_resolver", "UrlResolver"]
+__version__ = "1.0.3"

micron2html/__main__.py ADDED Viewed

@@ -0,0 +1,3 @@
+from .cli import main
+main()

micron2html/cli.py ADDED Viewed

@@ -0,0 +1,107 @@
+"""
+CLI tool: convert a .mu Micron file to HTML or plain text.
+Usage:
+    python -m micron2html.cli input.mu > output.html
+    python -m micron2html.cli input.mu -o output.html
+    cat page.mu | python -m micron2html.cli -
+    python -m micron2html.cli input.mu --format text
+"""
+import argparse
+import os
+import sys
+from .converter import MicronConverter
+_HTML_TEMPLATE = """\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{title}</title>
+  <style>
+{css}
+  </style>
+</head>
+<body>
+{body}
+</body>
+</html>
+"""
+def _bundled_css() -> str:
+    """Read the bundled MeshChat-parity stylesheet that ships with the package."""
+    css_path = os.path.join(os.path.dirname(__file__), "micron-meshchat.css")
+    try:
+        with open(css_path, "r", encoding="utf-8") as fh:
+            return fh.read()
+    except OSError:
+        return ""
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Convert Micron (.mu) markup to HTML or plain text"
+    )
+    parser.add_argument(
+        "input",
+        metavar="FILE",
+        help="Input .mu file (use - for stdin)",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        metavar="FILE",
+        default=None,
+        help="Output file (default: stdout)",
+    )
+    parser.add_argument(
+        "-f", "--format",
+        choices=["html", "text"],
+        default="html",
+        help="Output format (default: html)",
+    )
+    parser.add_argument(
+        "--fragment",
+        action="store_true",
+        help="HTML mode only: emit a fragment instead of a full <html> page",
+    )
+    parser.add_argument(
+        "--node-hash",
+        default="",
+        metavar="HASH",
+        help="Node destination hash (used to build internal link hrefs)",
+    )
+    args = parser.parse_args(argv)
+    if args.input == "-":
+        text = sys.stdin.read()
+        title = "Micron Page"
+    else:
+        with open(args.input, "r", encoding="utf-8") as fh:
+            text = fh.read()
+        title = os.path.basename(args.input)
+    converter = MicronConverter()
+    if args.format == "text":
+        output = converter.to_text(text)
+        if not output.endswith("\n"):
+            output += "\n"
+    else:
+        body = converter.convert(text, node_hash=args.node_hash)
+        if args.fragment:
+            output = body
+        else:
+            output = _HTML_TEMPLATE.format(title=title, css=_bundled_css(), body=body)
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(output)
+    else:
+        sys.stdout.write(output)
+if __name__ == "__main__":
+    main()

micron2html/converter.py ADDED Viewed

@@ -0,0 +1,703 @@
+"""
+Micron markup → HTML converter.
+Implements the full Micron specification as documented in:
+  https://github.com/markqvist/NomadNet/blob/master/nomadnet/ui/textui/Guide.py
+Default page colours match NomadNet's terminal defaults:
+  background  #000000  (black)
+  foreground  #aaaaaa  (light grey)
+"""
+import html
+import re
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+_TAG_RE = re.compile(r'<[^>]+>')
+_HEX = frozenset("0123456789abcdefABCDEF")
+# ---------------------------------------------------------------------------
+# Braille rendering
+#
+# The bundled Roboto Mono Nerd Font has no Braille glyphs at all, and the
+# system-monospace fallbacks on most platforms render Braille at much less
+# than full cell width — adjacent cells leave visible gaps and a row of
+# full-dot Braille reads as separated dots instead of a contiguous grid.
+#
+# We post-process the converted HTML to replace each Braille character
+# (U+2800–U+28FF) with a `<span class="mu-braille">` whose dots are
+# painted by CSS via `--mu-braille-dots` (a list of `radial-gradient`s,
+# one per raised dot). The result is font-independent: the cells always
+# render at exactly `1ch` wide with the dots at fixed fractional positions.
+#
+# The bundled `micron-meshchat.css` ships the matching `.mu-braille` rule.
+# ---------------------------------------------------------------------------
+_BRAILLE_DOT_POSITIONS = (
+    # (left%, top%) for each bit, in order: dot1 dot2 dot3 dot4 dot5 dot6 dot7 dot8
+    # 8-dot Braille fits in a 2×4 grid; spacing tuned so paired dots within
+    # a cell read as paired and rows of identical glyphs flow as a strip.
+    (25, 15), (25, 38), (25, 62),
+    (75, 15), (75, 38), (75, 62),
+    (25, 85), (75, 85),
+)
+_BRAILLE_RE = re.compile(r"<[^>]*>|[⠀-⣿]")
+def _braillify_html(html_str: str) -> str:
+    """Replace Braille codepoints in HTML text with CSS-drawn span elements.
+    Tags and attribute values are matched first (greedy alternation) and
+    pass through untouched, so nothing inside ``<a href="…">`` or
+    ``data-…`` attributes gets rewritten.
+    """
+    def repl(m: "re.Match[str]") -> str:
+        s = m.group(0)
+        if s.startswith("<"):
+            return s
+        bits = ord(s) - 0x2800
+        grads = []
+        for i in range(8):
+            if bits & (1 << i):
+                x, y = _BRAILLE_DOT_POSITIONS[i]
+                grads.append(
+                    f"radial-gradient(circle at {x}% {y}%, "
+                    f"currentColor 0.07em, transparent 0.08em)"
+                )
+        style = f' style="--mu-braille-dots:{",".join(grads)}"' if grads else ""
+        return f'<span class="mu-braille"{style}></span>'
+    return _BRAILLE_RE.sub(repl, html_str)
+# Type alias for a URL resolver: (raw_url, node_hash, base_path) -> href
+UrlResolver = Callable[[str, str, str], str]
+def default_url_resolver(url: str, node_hash: str, base_path: str) -> str:
+    """Library default: produce canonical NomadNet URLs without app-specific wrapping.
+    - http(s):// URLs pass through unchanged
+    - hash:/... and nomadnetwork:// URLs are returned canonicalized as hash://<hash>/<path>
+    - relative paths are resolved against (node_hash, base_path)
+    - /file/ links are blocked (return "#")
+    - empty/unknown returns "#"
+    Wrap this in your own resolver to produce app-specific hrefs (e.g. "/page?url=…").
+    """
+    if not url:
+        return "#"
+    if url.startswith("http://") or url.startswith("https://"):
+        return url
+    def _is_blocked(u: str) -> bool:
+        return "/file/" in u
+    if url.startswith("nomadnetwork://"):
+        body = url[len("nomadnetwork://"):]
+        return "#" if _is_blocked("/" + body) else f"hash://{body}"
+    if url.startswith("hash://"):
+        return "#" if _is_blocked(url) else url
+    if url.startswith("hash:/"):
+        return "#" if _is_blocked(url) else f"hash://{url[len('hash:/'):]}"
+    # Bare-hash format: <hex>:/path  or  :/path (current node)
+    colon_slash = url.find(":/")
+    if colon_slash == 0 and node_hash:
+        path_part = url[1:]
+        return "#" if _is_blocked(path_part) else f"hash://{node_hash}{path_part}"
+    if colon_slash > 0:
+        candidate = url[:colon_slash]
+        if 8 <= len(candidate) <= 64 and all(c in _HEX for c in candidate):
+            full = f"hash://{candidate}{url[colon_slash + 1:]}"
+            return "#" if _is_blocked(full) else full
+    if url.startswith("/") and node_hash:
+        return "#" if _is_blocked(url) else f"hash://{node_hash}{url}"
+    if node_hash and url:
+        base_dir = (base_path.rsplit("/", 1)[0] + "/") if "/" in base_path else "/"
+        return f"hash://{node_hash}{base_dir}{url}"
+    return "#"
+# ---------------------------------------------------------------------------
+# State dataclasses
+# ---------------------------------------------------------------------------
+@dataclass
+class _DocState:
+    """Document-level state that persists across lines."""
+    align: str = ""              # "", "left", "center", "right"
+    section: int = 0             # current section depth (number of leading >)
+    literal: bool = False        # inside a `= ... `= block
+    literal_lines: list = field(default_factory=list)
+    doc_fg: str = ""             # CSS color from #!fg= header
+    doc_bg: str = ""             # CSS color from #!bg= header
+@dataclass
+class _InlineState:
+    """Per-line inline formatting state."""
+    bold: bool = False
+    italic: bool = False
+    underline: bool = False
+    literal: bool = False
+    tag_stack: list = field(default_factory=list)  # list of (type_str, close_html)
+# ---------------------------------------------------------------------------
+# Converter
+# ---------------------------------------------------------------------------
+class MicronConverter:
+    """Convert Micron markup text to an HTML fragment.
+    Parameters
+    ----------
+    url_resolver
+        Callable ``(raw_url, node_hash, base_path) -> href`` invoked for every
+        link in the input. Defaults to :func:`default_url_resolver`, which
+        emits canonical ``hash://...`` URLs. Web frontends typically wrap
+        that with their own URL pattern (e.g. ``/page?url=…``).
+    """
+    def __init__(self, url_resolver: Optional[UrlResolver] = None):
+        self._url_resolver: UrlResolver = url_resolver or default_url_resolver
+    def convert(self, text: str, node_hash: str = "", base_path: str = "",
+                authenticated: bool = False, render_braille: bool = True) -> str:
+        """Convert a full Micron document to an HTML fragment.
+        Parameters
+        ----------
+        text
+            Micron source text.
+        node_hash
+            Destination hash of the source NomadNet node — used to resolve
+            relative and node-relative links.
+        base_path
+            Path of the current page (e.g. ``/page/index.mu``) — used to
+            resolve relative links against the page's directory.
+        authenticated
+            When ``True``, form fields are rendered as editable ``<input>``
+            elements. When ``False`` (default), they are rendered as
+            disabled inputs so guests can see them but not submit.
+        render_braille
+            When ``True`` (default), Braille characters (U+2800–U+28FF) in
+            the output are replaced with ``<span class="mu-braille">``
+            elements that render the dots via CSS — see the comment above
+            ``_braillify_html`` for rationale. Pass ``False`` to keep the
+            raw Braille codepoints (e.g. when feeding the result to a
+            downstream consumer that strips tags).
+        """
+        lines = text.split("\n")
+        doc = _DocState()
+        parts = []
+        for line in lines:
+            result = self._process_line(line, node_hash, base_path, authenticated, doc)
+            if result is not None:
+                parts.append(result)
+        # Flush any unclosed literal block
+        if doc.literal and doc.literal_lines:
+            content = html.escape("\n".join(doc.literal_lines))
+            parts.append(f'<pre class="mu-literal">{content}</pre>')
+        body = "\n".join(parts)
+        # Wrap with page-level colours if #!fg/#!bg headers were found
+        styles = []
+        if doc.doc_bg:
+            styles.append(f"background-color:{doc.doc_bg}")
+        if doc.doc_fg:
+            styles.append(f"color:{doc.doc_fg}")
+        if styles:
+            result = f'<div class="mu-page" style="{";".join(styles)}">{body}</div>'
+        else:
+            result = body
+        return _braillify_html(result) if render_braille else result
+    def convert_inline(self, text: str, node_hash: str = "", base_path: str = "",
+                       authenticated: bool = False, render_braille: bool = True) -> str:
+        """Convert a single line of Micron markup to inline HTML.
+        Returns formatted HTML *without* the ``<div class="mu-line">`` wrapper —
+        useful for rendering titles, message previews, brand elements, and
+        anywhere you need just the inline formatting (colors, bold, links).
+        Multi-line input has all newlines replaced with spaces.
+        ``render_braille`` controls the Braille post-processing — see
+        :meth:`convert` for details.
+        """
+        single = text.replace("\n", " ").strip()
+        result = self._parse_inline(single, node_hash, base_path, authenticated, _DocState())
+        return _braillify_html(result) if render_braille else result
+    def to_text(self, text: str) -> str:
+        """Render Micron markup to plain text, stripping formatting and colors.
+        Useful for message previews in conversation lists, search indexing,
+        accessibility tools, and CLI/terminal display where HTML is unwanted.
+        Links retain only their label text; URLs are dropped. Literal blocks
+        appear as their raw content. Page-level fg/bg headers are dropped.
+        """
+        html_out = self.convert(text, render_braille=False)
+        plain = _TAG_RE.sub("", html_out)
+        return html.unescape(plain).strip()
+    # ------------------------------------------------------------------
+    # Line-level processing
+    # ------------------------------------------------------------------
+    def _process_line(self, line: str, node_hash: str, base_path: str,
+                      authenticated: bool, doc: _DocState) -> Optional[str]:
+        # ---- Inside a multi-line literal block ----
+        if doc.literal:
+            if line.rstrip() == "`=":
+                doc.literal = False
+                content = html.escape("\n".join(doc.literal_lines))
+                doc.literal_lines = []
+                # MeshChat parity: literal lines inherit the surrounding
+                # section depth's indent (its parser applies section indent
+                # to every line, literal or not).
+                indent = max(0, doc.section - 1) * 20
+                style_attr = f' style="margin-left:{indent}px"' if indent else ''
+                return f'<pre class="mu-literal"{style_attr}>{content}</pre>'
+            doc.literal_lines.append(line)
+            return None
+        # ---- Comment / page-header lines (start with #) ----
+        if line.startswith("#"):
+            raw = line.strip()
+            if raw.startswith("#!bg="):
+                color = self._parse_header_color(raw[5:].strip())
+                if color:
+                    doc.doc_bg = color
+            elif raw.startswith("#!fg="):
+                color = self._parse_header_color(raw[5:].strip())
+                if color:
+                    doc.doc_fg = color
+            return None
+        stripped = line.rstrip("\r")
+        # ---- Literal block start/end: standalone `= line ----
+        if stripped.strip() == "`=":
+            doc.literal = True
+            doc.literal_lines = []
+            return None
+        # ---- Full reset: standalone `` resets doc-level state ----
+        if stripped.strip() == "``":
+            doc.align = ""
+            return None
+        # ---- Section headings: line starts with one or more > ----
+        if line.startswith(">"):
+            level = 0
+            while level < len(line) and line[level] == ">":
+                level += 1
+            doc.section = level
+            heading_text = line[level:].strip()
+            if not heading_text:
+                # MeshChat parity: empty heading line still emits a blank row
+                # (its parseLine returns null and the outer convertMicronToHtml
+                # loop appends a <br>). State (section depth) is updated above.
+                return '<div class="mu-blank"></div>'
+            inner = self._parse_inline(heading_text, node_hash, base_path,
+                                       authenticated, doc)
+            # Heading bg extends to the container's left edge for ALL levels
+            # (bg starts at 0 regardless of depth). The heading TEXT is
+            # tabbed inward via `padding-left` so deeper headings indent
+            # while their bg still spans the full row.
+            text_indent = (level - 1) * 20
+            style_attr = f' style="padding-left:{text_indent}px"' if text_indent else ''
+            # MeshChat parity: only heading levels 1–3 have a bg block; level
+            # 4+ falls back to the "plain" style (no bg, default fg). We
+            # render levels >3 as `.mu-line` so they get plain rendering.
+            if level == 1:
+                cls = "mu-h1"
+            elif level == 2:
+                cls = "mu-h2"
+            elif level == 3:
+                cls = "mu-h3"
+            else:
+                cls = "mu-line"
+            return f'<div class="{cls}"{style_attr}>{inner}</div>'
+        # ---- Dividers ----
+        # MeshChat parity: only lines starting with `-` produce dividers.
+        # `=-`, `==`, `===` etc. fall through and render as regular text.
+        s = line.strip()
+        if s and s[0] == "-":
+            indent = max(0, doc.section - 1) * 20
+            style_attr = f' style="margin-left:{indent}px"' if indent else ''
+            if len(s) == 1:
+                # `-` alone — thin solid rule (browser-default <hr>)
+                return f'<hr class="mu-hr"{style_attr}>'
+            if s[1] == "=":
+                # `-=` — row of `=` characters
+                return f'<hr class="mu-hr mu-hr-double"{style_attr}>'
+            # `--`, `-~`, `-*`, `-X`, etc. — styled divider; preserve the
+            # character so the renderer can repeat it across the row.
+            char_content = html.escape(s[1])
+            return f'<div class="mu-divider"{style_attr}>{char_content}</div>'
+        # ---- Empty line ----
+        if not line.strip():
+            return '<div class="mu-blank"></div>'
+        # ---- Regular text line ----
+        # MeshChat parity: no line-level bg from a leading `B` token (its
+        # parser doesn't do that). Bg only applies inside the explicit span.
+        inner = self._parse_inline(line, node_hash, base_path, authenticated, doc)
+        style_parts = []
+        if doc.align:
+            style_parts.append(f"text-align:{doc.align}")
+        indent = max(0, doc.section - 1) * 20
+        if indent:
+            style_parts.append(f"margin-left:{indent}px")
+        style_attr = f' style="{";".join(style_parts)}"' if style_parts else ''
+        return f'<div class="mu-line"{style_attr}>{inner}</div>'
+    # ------------------------------------------------------------------
+    # Inline parsing  (character-level state machine)
+    # ------------------------------------------------------------------
+    def _parse_inline(self, text: str, node_hash: str, base_path: str,
+                      authenticated: bool, doc: _DocState) -> str:
+        state = _InlineState()
+        out = []
+        i = 0
+        n = len(text)
+        while i < n:
+            ch = text[i]
+            # ---- Inline literal mode: pass through until closing `= ----
+            if state.literal:
+                if ch == "`" and i + 1 < n and text[i + 1] == "=":
+                    state.literal = False
+                    i += 2
+                else:
+                    out.append(html.escape(ch))
+                    i += 1
+                continue
+            # ---- Backslash escape ----
+            if ch == "\\" and i + 1 < n:
+                out.append(html.escape(text[i + 1]))
+                i += 2
+                continue
+            # ---- Backtick token ----
+            if ch == "`":
+                i += 1
+                if i >= n:
+                    out.extend(self._close_all(state))
+                    break
+                nc = text[i]
+                # Reset ALL formatting  (``)
+                if nc == "`":
+                    out.extend(self._close_all(state))
+                    doc.align = ""
+                    i += 1
+                # Bold  (`!)
+                elif nc == "!":
+                    if state.bold:
+                        out.append("</strong>")
+                        self._pop_tag(state, "strong")
+                    else:
+                        out.append("<strong>")
+                        state.tag_stack.append(("strong", "</strong>"))
+                    state.bold = not state.bold
+                    i += 1
+                # Underline  (`_)
+                elif nc == "_":
+                    if state.underline:
+                        out.append("</span>")
+                        self._pop_tag(state, "underline")
+                    else:
+                        out.append('<span class="mu-ul">')
+                        state.tag_stack.append(("underline", "</span>"))
+                    state.underline = not state.underline
+                    i += 1
+                # Italic  (`*)
+                elif nc == "*":
+                    if state.italic:
+                        out.append("</em>")
+                        self._pop_tag(state, "em")
+                    else:
+                        out.append("<em>")
+                        state.tag_stack.append(("em", "</em>"))
+                    state.italic = not state.italic
+                    i += 1
+                # Foreground color  (`Fxxx or `FTxxxxxx)
+                elif nc == "F":
+                    i += 1
+                    color, i = self._parse_color(text, i, n)
+                    if color:
+                        out.append(f'<span style="color:{color}">')
+                        state.tag_stack.append(("fg", "</span>"))
+                # Reset foreground  (`f)
+                elif nc == "f":
+                    self._close_innermost(state, "fg", out)
+                    i += 1
+                # Background color  (`Bxxx or `BTxxxxxx)
+                elif nc == "B":
+                    i += 1
+                    color, i = self._parse_color(text, i, n)
+                    if color:
+                        out.append(f'<span style="background-color:{color}">')
+                        state.tag_stack.append(("bg", "</span>"))
+                # Reset background  (`b)
+                elif nc == "b":
+                    self._close_innermost(state, "bg", out)
+                    i += 1
+                # Alignment — updates persistent doc state
+                elif nc == "c":
+                    doc.align = "center"
+                    i += 1
+                elif nc == "l":
+                    doc.align = "left"
+                    i += 1
+                elif nc == "r":
+                    doc.align = "right"
+                    i += 1
+                elif nc == "a":
+                    doc.align = ""
+                    i += 1
+                # Inline literal mode  (`=)
+                elif nc == "=":
+                    state.literal = True
+                    i += 1
+                # Link  (`[label`URL`field1=v1`field2=v2…] or `[URL])
+                elif nc == "[":
+                    i += 1  # past [
+                    end = text.find("]", i)
+                    if end != -1:
+                        link_inner = text[i:end]
+                        parts = link_inner.split("`")
+                        if len(parts) >= 2:
+                            lbl, url = parts[0], parts[1]
+                            # Preserve all backtick-separated field specs.
+                            # Earlier versions only took parts[2], silently
+                            # dropping every field after the first.
+                            fspec = "`".join(parts[2:]) if len(parts) > 2 else ""
+                        else:
+                            url = parts[0]
+                            lbl = ""
+                            fspec = ""
+                        href = self._resolve_url(url, node_hash, base_path)
+                        display = html.escape(lbl) if lbl else html.escape(url)
+                        extra = (f' data-field-spec="{html.escape(fspec)}"'
+                                 if fspec else "")
+                        out.append(
+                            f'<a href="{html.escape(href)}" class="mu-link"{extra}>'
+                            f'{display}</a>'
+                        )
+                        i = end + 1
+                    else:
+                        out.append("[")
+                # Field  (`<flags|name`default>)
+                # MeshChat parity: a field requires a backtick between
+                # `<flags|name` and `default>`. Without it, MeshChat's
+                # parseField returns null and the `<` is silently eaten.
+                # We mirror that exactly so checkbox/radio shorthand that
+                # omits the backtick (`<?|name|value>`, `<^|name|value>`)
+                # produces the same broken render in both renderers.
+                elif nc == "<":
+                    field_start = i + 1
+                    backtick_pos = text.find("`", field_start)
+                    end = text.find(">", backtick_pos + 1) if backtick_pos != -1 else -1
+                    if backtick_pos != -1 and end != -1:
+                        field_content = text[field_start:backtick_pos]
+                        field_data = text[backtick_pos + 1:end]
+                        out.append(self._render_field(field_content, field_data, authenticated))
+                        i = end + 1
+                    else:
+                        # Malformed — eat the `<` silently, matching MeshChat.
+                        i += 1
+                # Dynamic include  (`{URL`refresh})
+                elif nc == "{":
+                    end = text.find("}", i + 1)
+                    if end != -1:
+                        dyn_inner = text[i + 1:end]
+                        dyn_url = dyn_inner.split("`")[0].strip()
+                        href = self._resolve_url(dyn_url, node_hash, base_path)
+                        out.append(
+                            f'<a href="{html.escape(href)}" class="mu-dynamic">[live]</a>'
+                        )
+                        i = end + 1
+                    else:
+                        out.append("`{")
+                        i += 1
+                else:
+                    # Unknown token — silently consume both the backtick and
+                    # the unknown char, matching the behaviour of NomadNet's
+                    # MicronParser (and Liam Cottle's MicronParser.js port).
+                    # If you want a literal backtick, use `\`` to escape it.
+                    i += 1
+                continue
+            out.append(html.escape(ch))
+            i += 1
+        out.extend(self._close_all(state))
+        return "".join(out)
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+    def _parse_color(self, text: str, i: int, n: int):
+        """Parse a Micron color token after the F/B prefix.
+        Format: 3 hex chars — each nibble doubled (f→ff, 8→88, 0→00).
+        MeshChat parity:
+          - Always consume the next 3 chars after F/B (if available),
+            regardless of whether they're valid hex. This matches NomadNet's
+            MicronParser and Liam Cottle's MicronParser.js, both of which
+            do `line.substr(i+1,3)` + `skip = 3` unconditionally.
+          - If the 3 chars aren't valid hex, no colour is applied (the
+            colour-state holds the invalid string; rendering ignores it),
+            but the 3 chars are still consumed so they don't leak as text.
+          - The 24-bit `T<6hex>` extension that Micron2HTML used to accept
+            has been dropped — neither MeshChat nor NomadNet support it.
+        Returns (css_color_str | None, new_index).
+        """
+        if i + 3 <= n:
+            h3 = text[i:i + 3]
+            if all(c in _HEX for c in h3):
+                return "#" + "".join(c * 2 for c in h3).lower(), i + 3
+            # Invalid hex — still consume the 3 chars to match MeshChat,
+            # but signal "no colour" so the caller doesn't open a span.
+            return None, i + 3
+        return None, i
+    def _parse_header_color(self, value: str) -> Optional[str]:
+        """Parse a #!fg=X or #!bg=X color value.  Returns CSS color or None."""
+        v = value.strip()
+        if len(v) == 3 and all(c in _HEX for c in v):
+            return "#" + "".join(c * 2 for c in v).lower()
+        if len(v) == 6 and all(c in _HEX for c in v):
+            return f"#{v.lower()}"
+        return None
+    def _resolve_url(self, url: str, node_hash: str, base_path: str) -> str:
+        """Convert a Micron URL to an href via the configured resolver."""
+        return self._url_resolver(url, node_hash, base_path)
+    def _render_field(self, field_content: str, field_data: str,
+                      authenticated: bool = False) -> str:
+        """Render a Micron input field.
+        Mirrors `parseField()` in liamcottle/reticulum-meshchat MicronParser.js.
+        Formats (the `\\`` is the required separator between flags|name and
+        default/label):
+          text/password : `<[size][!]|name\\`default>`
+          checkbox      : `<?[size]|field_name|value[|*]\\`label>`
+          radio         : `<^[size]|field_name|value[|*]\\`label>`
+        `field_content` is everything between `<` and the backtick.
+        `field_data` is everything between the backtick and `>`.
+        """
+        dis = "" if authenticated else " disabled"
+        field_masked = False
+        field_width = 24
+        field_type = "field"
+        field_name = field_content
+        field_value = ""
+        field_prechecked = False
+        if "|" in field_content:
+            f_components = field_content.split("|")
+            field_flags = f_components[0]
+            field_name = f_components[1] if len(f_components) > 1 else ""
+            if "^" in field_flags:
+                field_type = "radio"
+                field_flags = field_flags.replace("^", "")
+            elif "?" in field_flags:
+                field_type = "checkbox"
+                field_flags = field_flags.replace("?", "")
+            elif "!" in field_flags:
+                field_masked = True
+                field_flags = field_flags.replace("!", "")
+            if field_flags:
+                try:
+                    w = int(field_flags)
+                    field_width = min(w, 256)
+                except ValueError:
+                    pass
+            if len(f_components) > 2:
+                field_value = f_components[2]
+            if len(f_components) > 3 and f_components[3] == "*":
+                field_prechecked = True
+        name_attr = html.escape(field_name)
+        if field_type in ("checkbox", "radio"):
+            value = field_value or field_data
+            label = field_data
+            chk = " checked" if field_prechecked else ""
+            return (f'<input type="{field_type}" name="{name_attr}" '
+                    f'value="{html.escape(value)}"{dis}{chk}> '
+                    f'{html.escape(label)}')
+        # Text / password
+        itype = "password" if field_masked else "text"
+        return (f'<input type="{itype}" name="{name_attr}" '
+                f'value="{html.escape(field_data)}" '
+                f'size="{field_width}"{dis} class="mu-field">')
+    def _pop_tag(self, state: _InlineState, tag_type: str) -> None:
+        for j in range(len(state.tag_stack) - 1, -1, -1):
+            if state.tag_stack[j][0] == tag_type:
+                state.tag_stack.pop(j)
+                return
+    def _close_innermost(self, state: _InlineState, tag_type: str, out: list) -> None:
+        for j in range(len(state.tag_stack) - 1, -1, -1):
+            if state.tag_stack[j][0] == tag_type:
+                out.append(state.tag_stack[j][1])
+                state.tag_stack.pop(j)
+                return
+    def _close_all(self, state: _InlineState) -> list:
+        tags = [close for _, close in reversed(state.tag_stack)]
+        state.tag_stack.clear()
+        state.bold = state.italic = state.underline = False
+        state.literal = False
+        return tags

micron2html/micron-meshchat.css ADDED Viewed

@@ -0,0 +1,245 @@
+/* Micron2HTML — default stylesheet (v1.0.4)
+ *
+ * Drop this in alongside the converter's HTML output for instant rendering
+ * that matches Reticulum MeshChat's NomadNet renderer. All rules are scoped
+ * to .mu-* classes so they won't bleed into the rest of your page.
+ *
+ * Pairs with the bundled `RobotoMonoNerdFont-Regular.ttf` (CC BY 4.0, by
+ * Christian Robertson + Nerd Fonts contributors) — drop both files in the
+ * same directory and the @font-face below picks it up automatically.
+ *
+ * The Braille block (U+2800-28FF) is carved out of Roboto Mono and routed
+ * to a system-font fallback chain — Roboto Mono's Braille glyphs don't
+ * reach the cell edges, so a row of full-dot Braille reads as gappy dots
+ * instead of a contiguous grid (MeshChat-parity bug, fixed here so every
+ * downstream consumer gets the right rendering for free).
+ */
+@font-face {
+  font-family: 'Roboto Mono Nerd Font';
+  src: url('./RobotoMonoNerdFont-Regular.ttf') format('truetype');
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+  unicode-range: U+0000-27FF, U+2900-FFFF, U+10000-10FFFF;
+}
+/* Braille — system font fallback. None of these are bundled; the browser
+ * uses whichever the user's OS ships (Linux usually has Noto or DejaVu,
+ * macOS has Apple Symbols, Windows has Segoe UI Symbol). If none are
+ * installed, the browser falls back to its generic monospace default and
+ * the gap returns — but that's strictly better than always-gappy, and
+ * adds zero KB to the page weight. */
+@font-face {
+  font-family: 'Roboto Mono Nerd Font';
+  src: local('Noto Sans Mono'),
+       local('DejaVu Sans Mono'),
+       local('Symbola'),
+       local('Apple Symbols'),
+       local('Segoe UI Symbol');
+  font-weight: 400;
+  font-style: normal;
+  unicode-range: U+2800-28FF;
+}
+/* ---- Page wrapper -----------------------------------------------------
+ * Emitted when the source has `#!bg=` or `#!fg=` headers; otherwise the
+ * Micron content is bare. For standalone use, wrap your converter output
+ * in `<div class="mu-page">` to get the full terminal aesthetic. */
+.mu-page {
+  font-family: "Roboto Mono Nerd Font", "Cascadia Code", "JetBrains Mono",
+               "Consolas", "Courier New", monospace;
+  font-size: 16.64px;
+  line-height: normal;
+  color: #dddddd;
+  background: #000000;
+  padding: 12px;
+  white-space: pre;
+  /* Only the Regular weight ships with Micron2HTML — disable browser
+   * synthesis so faux-bold doesn't break monospace alignment in centred
+   * lines that mix bold and non-bold spans. Use the text-shadow trick
+   * below to fake a bold visual without changing character widths. */
+  font-synthesis-weight: none;
+  font-kerning: none;
+  /* No line-wrap on Micron content — long lines scroll horizontally so
+   * box-drawing diagrams and ASCII art stay aligned. */
+  overflow: auto;
+}
+/* ---- Section headings (MeshChat STYLES_DARK) ----
+ * heading1: bg #bbbbbb, default fg #222222 (overridable by author Fxxx)
+ * heading2: bg #999999, default fg #111111
+ * heading3: bg #777777, default fg #000000
+ *
+ * The bg always extends to the container's left edge; the heading text is
+ * tabbed in via `padding-left` (set inline by the converter from depth). */
+.mu-h1, .mu-h2, .mu-h3 {
+  display: block;
+  font-family: inherit;
+  font-weight: bold;
+  /* Closing the inflated leading the Nerd Font carries — keeps adjacent
+   * box-drawing rows touching across the heading. Scales with font-size. */
+  margin: 0 0 -1.08em 0;
+  white-space: pre;
+}
+.mu-h1 { background: #bbbbbb; color: #222222; }
+.mu-h2 { background: #999999; color: #111111; }
+.mu-h3 { background: #777777; color: #000000; }
+/* ---- Body lines & blanks --------------------------------------------- */
+.mu-line {
+  display: block;
+  margin: 0 0 -1.08em 0;
+  line-height: 1;
+  white-space: pre;
+}
+.mu-blank {
+  display: block;
+  line-height: 1;
+  height: 1em;
+  margin-bottom: -1.08em;
+}
+/* ---- Dividers --------------------------------------------------------
+ *   `-` / `--`  → thin solid line (browser-default <hr> with currentColor)
+ *   `-=` / `=-` → row of `=` characters (CSS `::before` content)
+ *   `-X` styled → row of the source char (text-shadow repeats it 150x)
+ * Matches what MeshChat displays via its own browser-default <hr>. */
+.mu-hr {
+  display: block;
+  border: 0;
+  border-top: 1px solid currentColor;
+  margin: 0 0 -1.08em 0;
+  height: 0;
+}
+.mu-hr-double {
+  display: block;
+  border: 0;
+  margin: 0 0 -1.08em 0;
+  height: 1em;
+  overflow: hidden;
+  white-space: nowrap;
+  color: inherit;
+  font-family: inherit;
+}
+.mu-hr-double::before {
+  content: "================================================================================================================================================================";
+}
+.mu-divider {
+  display: block;
+  margin: 0 0 -1.08em 0;
+  overflow: hidden;
+  white-space: nowrap;
+  color: inherit;
+  text-shadow:
+    1ch 0, 2ch 0, 3ch 0, 4ch 0, 5ch 0, 6ch 0, 7ch 0, 8ch 0, 9ch 0, 10ch 0,
+    11ch 0, 12ch 0, 13ch 0, 14ch 0, 15ch 0, 16ch 0, 17ch 0, 18ch 0, 19ch 0, 20ch 0,
+    21ch 0, 22ch 0, 23ch 0, 24ch 0, 25ch 0, 26ch 0, 27ch 0, 28ch 0, 29ch 0, 30ch 0,
+    31ch 0, 32ch 0, 33ch 0, 34ch 0, 35ch 0, 36ch 0, 37ch 0, 38ch 0, 39ch 0, 40ch 0,
+    41ch 0, 42ch 0, 43ch 0, 44ch 0, 45ch 0, 46ch 0, 47ch 0, 48ch 0, 49ch 0, 50ch 0,
+    51ch 0, 52ch 0, 53ch 0, 54ch 0, 55ch 0, 56ch 0, 57ch 0, 58ch 0, 59ch 0, 60ch 0,
+    61ch 0, 62ch 0, 63ch 0, 64ch 0, 65ch 0, 66ch 0, 67ch 0, 68ch 0, 69ch 0, 70ch 0,
+    71ch 0, 72ch 0, 73ch 0, 74ch 0, 75ch 0, 76ch 0, 77ch 0, 78ch 0, 79ch 0, 80ch 0,
+    81ch 0, 82ch 0, 83ch 0, 84ch 0, 85ch 0, 86ch 0, 87ch 0, 88ch 0, 89ch 0, 90ch 0,
+    91ch 0, 92ch 0, 93ch 0, 94ch 0, 95ch 0, 96ch 0, 97ch 0, 98ch 0, 99ch 0, 100ch 0,
+    101ch 0, 102ch 0, 103ch 0, 104ch 0, 105ch 0, 106ch 0, 107ch 0, 108ch 0, 109ch 0, 110ch 0,
+    111ch 0, 112ch 0, 113ch 0, 114ch 0, 115ch 0, 116ch 0, 117ch 0, 118ch 0, 119ch 0, 120ch 0,
+    121ch 0, 122ch 0, 123ch 0, 124ch 0, 125ch 0, 126ch 0, 127ch 0, 128ch 0, 129ch 0, 130ch 0,
+    131ch 0, 132ch 0, 133ch 0, 134ch 0, 135ch 0, 136ch 0, 137ch 0, 138ch 0, 139ch 0, 140ch 0,
+    141ch 0, 142ch 0, 143ch 0, 144ch 0, 145ch 0, 146ch 0, 147ch 0, 148ch 0, 149ch 0, 150ch 0;
+}
+/* ---- Braille (CSS-drawn dots) ---------------------------------------
+ * The converter replaces every Braille character (U+2800–U+28FF) with
+ * a `<span class="mu-braille">` whose `--mu-braille-dots` custom
+ * property holds a list of `radial-gradient`s, one per raised dot.
+ * Roboto Mono Nerd Font has no Braille glyphs, and most system-monospace
+ * fallbacks render Braille narrower than the cell — drawing the dots
+ * ourselves keeps every cell at exactly `1ch` and lets a row of full-dot
+ * Braille flow as a contiguous grid. */
+.mu-braille {
+  display: inline-block;
+  width: 1ch;
+  height: 1em;
+  vertical-align: baseline;
+  position: relative;
+}
+.mu-braille::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--mu-braille-dots, transparent);
+  background-repeat: no-repeat;
+}
+/* ---- Bold (fake-bold via text-shadow) -------------------------------
+ * We only ship the Regular weight, so synthesised bold would shift glyph
+ * widths and break monospace alignment. Drawing the glyph 0.5px to the
+ * right thickens it visually without changing the layout box. */
+strong {
+  font-weight: normal;
+  text-shadow: 0.5px 0 0 currentColor;
+}
+/* ---- Links -----------------------------------------------------------
+ * `color: inherit` so the surrounding span colour flows through (matches
+ * MeshChat — links don't have a fixed colour, they take the parser state). */
+.mu-link {
+  color: inherit;
+  text-decoration: none;
+}
+.mu-link:hover { text-decoration: underline; }
+/* ---- Inline underline & dynamic-include link ---- */
+.mu-ul { text-decoration: underline; }
+.mu-dynamic {
+  color: #c8905b;
+  font-style: italic;
+}
+/* ---- Literal blocks (`= ... `=) --------------------------------------
+ * Plain pre-styled text — no border, no bg, no padding. MeshChat doesn't
+ * box literal content; it flows inline at the same font/colour as the
+ * surrounding paragraph. */
+.mu-literal {
+  white-space: pre;
+  font-family: inherit;
+  font-size: inherit;
+  line-height: 1;
+  color: inherit;
+  background: transparent;
+  border: 0;
+  padding: 0;
+  margin: 0;
+}
+/* ---- Form fields -----------------------------------------------------
+ * Text/password inputs: white background with mid-grey text (matches
+ * MeshChat's disabled-input look). Padding bumped from default browser
+ * metrics so they read at body size. */
+.mu-field {
+  background: #ffffff;
+  border: 1px solid #333333;
+  color: #bababa;
+  font-family: inherit;
+  font-size: inherit;
+  padding: 6px 8px;
+  border-radius: 2px;
+  cursor: not-allowed;
+}
+.mu-field:not([disabled]) {
+  color: #bababa;
+  cursor: text;
+  outline: none;
+}
+.mu-field:focus { outline: none; border-color: #5ba3c9; }
+input[type="checkbox"], input[type="radio"] {
+  accent-color: #5ba3c9;
+  cursor: pointer;
+  margin: 0 4px 0 0;
+}
+input[type="checkbox"][disabled], input[type="radio"][disabled] {
+  cursor: not-allowed;
+  opacity: 0.5;
+}

micron2html-1.0.5.dist-info/METADATA ADDED Viewed

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: Micron2HTML
+Version: 1.0.5
+Summary: Convert Micron markup (NomadNet) to HTML
+Author-email: James Manley <jamesmanley1992@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/JamesM92/Micron2HTML
+Project-URL: Repository, https://github.com/JamesM92/Micron2HTML
+Project-URL: Issues, https://github.com/JamesM92/Micron2HTML/issues
+Keywords: nomadnet,reticulum,micron,markup,html,converter
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+# Micron2HTML
+A Python library and CLI tool that converts [Micron](https://github.com/markqvist/NomadNet) markup to HTML.
+Micron is the terminal markup language used by [NomadNet](https://github.com/markqvist/NomadNet) nodes. This library lets you render Micron pages in web browsers and other HTML-capable environments.
+## Installation
+```bash
+pip install Micron2HTML
+```
+Or from source:
+```bash
+git clone https://github.com/JamesM92/Micron2HTML.git
+cd Micron2HTML
+pip install -e .
+```
+No runtime dependencies — pure Python 3.9+.
+## Library usage
+```python
+from micron2html import MicronConverter
+conv = MicronConverter()
+html = conv.convert(micron_text)
+# With context for resolving internal links
+html = conv.convert(
+    micron_text,
+    node_hash="a1b2c3d4...",    # destination hash of the source node
+    base_path="/page/index.mu", # current page path
+    authenticated=True,         # render form fields as interactive inputs
+)
+# Inline-only — for titles, message previews, brand strings.
+# Returns formatted HTML without the <div class="mu-line"> wrapper.
+title_html = conv.convert_inline("`F4af`!My Node`!`f")
+```
+`convert()` returns an HTML fragment (no `<html>` or `<body>` wrapper). Wrap it in your own template or use the CLI for standalone pages.
+### Custom URL resolution
+By default, links resolve to canonical `hash://<hash>/<path>` URLs (and `http(s)://` URLs pass through). If your web app uses a different URL pattern — e.g. `/page?url=…` — pass a resolver callback:
+```python
+import urllib.parse
+from micron2html import MicronConverter, default_url_resolver
+def my_resolver(url: str, node_hash: str, base_path: str) -> str:
+    canonical = default_url_resolver(url, node_hash, base_path)
+    if canonical.startswith("hash://"):
+        return f"/page?url={urllib.parse.quote(canonical, safe='')}"
+    return canonical
+conv = MicronConverter(url_resolver=my_resolver)
+```
+### Default stylesheet
+A MeshChat-parity stylesheet ships with the package, named to make the design intent explicit:
+```html
+<link rel="stylesheet" href="/static/micron-meshchat.css">
+```
+The file lives at `micron2html/micron-meshchat.css` in the installed package — copy it into your static directory, or import it via your build pipeline. All rules are scoped to `.mu-*` classes so they won't bleed into the rest of your page.
+## CLI usage
+```bash
+# Convert a file and print to stdout
+micron-convert page.mu
+# Convert and write to a file
+micron-convert page.mu -o page.html
+# Read from stdin
+cat page.mu | micron-convert -
+# Output an HTML fragment instead of a full page
+micron-convert page.mu --fragment
+# Set the node hash so internal links resolve correctly
+micron-convert page.mu --node-hash a1b2c3d4e5f6...
+```
+## Micron syntax
+### Comments and headers
+```
+# This is a comment — the whole line is stripped from output
+#!bg=2a2a2a   Set page background colour (3 or 6 hex digits)
+#!fg=aaaaaa   Set page foreground colour
+```
+### Headings and sections
+```
+>Section heading      h1
+>>Subsection          h2
+>>>Sub-subsection     h3
+```
+### Dividers
+```
+---     Horizontal rule
+-=      Double horizontal rule
+-<x>    Styled divider — repeats character `x` (e.g. -* renders centred * row)
+```
+### Inline formatting
+```
+`!text`!      Bold
+`*text`*      Italic
+`_text`_      Underline
+`Fxxx         Set foreground colour (3-hex shorthand: each digit doubled — F40 → #ff4400)
+`FTxxxxxx     Set foreground colour (6-hex true colour)
+`f            Reset foreground colour to default
+`Bxxx         Set background colour (3-hex shorthand)
+`BTxxxxxx     Set background colour (6-hex)
+`b            Reset background colour to default
+``            Reset ALL inline formatting (bold, italic, underline, colours, alignment)
+```
+### Alignment
+```
+`a            Left align (default)
+`c            Centre align
+`r            Right align
+```
+### Links
+```
+`[Label`href]                        Labelled link
+`[`http://example.com]               URL-only link
+`[Label`/relative/path.mu]           Relative path (resolved against base_path)
+`[Label`hash://a1b2c3/page.mu]       Node link (resolved against node_hash)
+```
+### Literal blocks
+```
+`=
+This text is rendered verbatim in a <pre> block.
+No Micron formatting is applied inside.
+`=
+```
+### Form fields
+Fields render as disabled `<input>` elements unless `authenticated=True` is passed to `convert()`.
+```
+`<name`default>             Text input — name with optional default value
+`<size|name`default>        Text input with character size (e.g. `<20|name`>)
+`<!|name`default>           Password input (! flag)
+`<?|name|value>             Checkbox (* at end pre-checks: `<?|name|value|*>)
+`<^|name|value>             Radio button (* at end pre-selects)
+```
+## Security
+All user-supplied content is HTML-escaped before output. The converter is safe to use with untrusted Micron input — XSS via markup is explicitly tested in the test suite.
+External URLs are rendered as plain `<a>` links. File download links (`file://`) are blocked. Internal NomadNet links are resolved to application-relative hrefs.
+## Running tests
+```bash
+pip install pytest
+pytest tests/
+```
+## License
+MIT — see [LICENSE](LICENSE).
+## Related
+- [NomadNet](https://github.com/markqvist/NomadNet) — the NomadNet node software (defines the Micron spec)
+- [Ansi2MicronMU](https://github.com/JamesM92/Ansi2MicronMU) — the other direction: convert ANSI terminal output (e.g. from `git log --color`, `htop`, `ls --color`) into Micron. Pair with Micron2HTML to expose existing CLI tools through a NomadNet site or a web frontend:
+  ```bash
+  git log --color=always | ansi2micron | micron-convert -
+  ```
+- [NomadDockerNet](https://github.com/JamesM92/NomadDockerNet) — the web browser that uses this library

micron2html-1.0.5.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,12 @@
+micron2html/RobotoMonoNerdFont-Regular.ttf,sha256=M1f-wczi0wyaVHqzX1vRdCwAXOY0MJZCd1C98WC-Co0,2389336
+micron2html/__init__.py,sha256=vSuREPZzjb477beWMTKY59ha-WeXTfhkA8TLTH3rBKA,166
+micron2html/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+micron2html/cli.py,sha256=EwmaZS8z09lwAVnQz9UgkV9gA-VxtYQEYVwFXNhDSKM,2701
+micron2html/converter.py,sha256=xpIeFPx79jrmOf1Pfd0gXYo25dbjp0RzCxBO-qHDjjo,29036
+micron2html/micron-meshchat.css,sha256=j2Is7iVIItQ0TPKKnMBb9Y3seCaRB2mQfbZour7mjNo,9108
+micron2html-1.0.5.dist-info/licenses/LICENSE,sha256=CujYd6ElAA7VqlV0v2xV0ZSGv5xEJel0-2OTAt7oCSM,1069
+micron2html-1.0.5.dist-info/METADATA,sha256=-WrhTuKwRQ-CkTM8SS0Sl5GVuBXGmIBBRU74_J3tUSo,6896
+micron2html-1.0.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+micron2html-1.0.5.dist-info/entry_points.txt,sha256=RUScR5OAU7gvP5CkunlJOEHkYnZ_RvJbsvw09riagZE,56
+micron2html-1.0.5.dist-info/top_level.txt,sha256=dAyG4ERpgklG3XCHIHqqPVI9YuzUPqSMYa4QigkiJbc,12
+micron2html-1.0.5.dist-info/RECORD,,

micron2html-1.0.5.dist-info/WHEEL ADDED Viewed

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

micron2html-1.0.5.dist-info/entry_points.txt ADDED Viewed

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

micron2html-1.0.5.dist-info/licenses/LICENSE ADDED Viewed

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

micron2html-1.0.5.dist-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ micron2html