mymarkup 0.1.0__tar.gz

mymarkup-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: mymarkup
+Version: 0.1.0
+Summary: mymarkup package
+Requires-Python: >=3.9

mymarkup-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mymarkup"
+version = "0.1.0"
+description = "mymarkup package"
+requires-python = ">=3.9"
+
+[project.scripts]
+mymarkup = "mymarkup.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+mymarkup = ["styles.css", "template.html"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

mymarkup-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mymarkup-0.1.0/src/mymarkup/__init__.py

@@ -0,0 +1 @@
+from .mymarkup import Context, render, metadata

mymarkup-0.1.0/src/mymarkup/__main__.py

@@ -0,0 +1,125 @@
+from pathlib import Path
+from html import escape
+import traceback
+import os
+import shutil
+
+import mymarkup
+
+
+class Context(mymarkup.Context):
+    def __init__(self, root_directory: Path, relative_path: Path):
+        self._index = self.generate_index_html(root_directory, relative_path)
+        self._breadcrumbs = self.generate_breadcrumbs_html(root_directory, relative_path)
+
+    def index(self):
+        return self._index
+
+    def breadcrumbs(self):
+        return self._breadcrumbs
+
+    def generate_index_html(self, root_directory: Path, relative_path: Path) -> str:
+        html = "<table><tr><th>Name</th><th>Description</th></tr>"
+        directory = root_directory / relative_path.parent
+        for path in directory.iterdir():
+            if path.name == relative_path.name:
+                continue
+            if path.is_dir():
+                href = path.name
+                path = path / "index.mu"
+            else:
+                href = path.with_suffix(".html").name
+            if not (path.exists() and path.suffix == ".mu"):
+                continue
+            source = path.read_text(encoding="utf-8")
+            metadata = mymarkup.metadata(source)
+            html += f'<tr><td><a href="{escape(href, quote=True)}">{metadata.title}</a></td><td>{metadata.description}</td></tr>'
+        html += "</table>"
+        return html
+
+    def generate_breadcrumbs_html(self, root_directory: Path, relative_path: Path) -> str:
+        breadcrumbs = [("Home", "/")]
+        current = root_directory
+        parts = relative_path.parts[:-1] if relative_path.name == "index.mu" else relative_path.parts
+        href_parts = []
+        for name in parts:
+            current = current / name
+            href_parts.append(name)
+            if current.is_dir():
+                source = (current / "index.mu").read_text(encoding="utf-8")
+                title = mymarkup.metadata(source).title
+            elif current.suffix == ".mu":
+                source = current.read_text(encoding="utf-8")
+                title = mymarkup.metadata(source).title
+            else:
+                raise Exception(f"Unknown file type when generating breadcrumbs: {current}")
+            href = "/" + "/".join([escape(x) for x in href_parts]) + "/"
+            breadcrumbs.append((title, href))
+        html = '<div class="breadcrumbs">'
+        for title, href in breadcrumbs[:-1]:
+            html += f'<a href="{href}">{title}</a> / '
+        html += f'{breadcrumbs[-1][0]}</div>'
+        return html
+
+
+def get_all_markup_paths(directory: Path) -> list[Path]:
+    return [
+        path.relative_to(directory)
+        for path in directory.rglob("*.mu")
+        if path.is_file()
+    ]
+
+
+def convert_markup_to_html(root_directory: Path, relative_path: Path) -> None:
+    input_path = root_directory / relative_path
+    output_path = root_directory / relative_path.with_suffix(".html")
+    input_text = input_path.read_text(encoding="utf-8")
+    input_text = f":breadcrumbs:\n\n{input_text}"
+    context = Context(root_directory, relative_path)
+    markup = mymarkup.render(input_text, context)
+    title = mymarkup.metadata(input_text, context).title
+    template = (Path(__file__).parent / "template.html").read_text(encoding="utf-8")
+    html = template.replace("TITLE", title).replace("MARKUP", markup)
+    output_path.write_text(html, encoding="utf-8")
+
+
+def rm_html_files(root_directory: Path) -> int:
+    ignore_lines = [x.strip() for x in Path(".gitignore").read_text(encoding="utf-8").split("\n") if x.strip()]
+    count = 0
+    for path in root_directory.rglob("*.html"):
+        if any([part in ignore_lines for part in path.parts]):
+            continue
+        if path.is_file():
+            path.unlink()
+            count += 1
+    return count
+
+
+def build_site(root_directory: Path) -> None:
+    root_directory = root_directory.resolve()
+    print(f" [+] Removing all .html files from  {root_directory}")
+    count = rm_html_files(root_directory)
+    print(f" [+] Removed {count} .html files")
+    relative_markup_paths = get_all_markup_paths(root_directory)
+    print(f" [+] Detected {len(relative_markup_paths)} files to to render")
+    for relative_markup_path in relative_markup_paths:
+        print(f" [+] Rendering {relative_markup_path}")
+        try:
+            convert_markup_to_html(root_directory, relative_markup_path)
+        except Exception as e:
+            raise Exception(f"Error processing {relative_markup_path}: {e}")
+    print(" [+] Copying styles.css")
+    shutil.copy2(Path(__file__).parent / "styles.css", root_directory / "styles.css")
+
+
+def main() -> int:
+    try:
+        build_site(Path("."))
+        return 0
+    except Exception as e:
+        print(f" [-] {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mymarkup-0.1.0/src/mymarkup/mymarkup.py

@@ -0,0 +1,467 @@
+import re
+import inspect
+from html import escape
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import urlparse
+
+
+SAFE_SCHEMES = {"http", "https", "mailto"}
+
+
+@dataclass
+class Metadata:
+    title: str
+    description: str
+
+
+class Context:
+    def index(self):
+        raise Exception("index undefined")
+
+    def breadcrumbs(self):
+        raise Exception("breadcrumbs undefined")
+
+
+class Token:
+    def render(self, context: Context):
+        raise Exception("render undefined")
+
+
+class BlockToken(Token):
+    subclasses = []
+
+    def __init_subclass__(cls):
+        BlockToken.subclasses.append(cls)
+
+    @classmethod
+    def parse(_, lines: list[str], i: int) -> tuple["BlockToken", int]:
+        for cls in BlockToken.subclasses:
+            token, i = cls.parse(lines, i)
+            if token:
+                return token, i
+        raise Exception(f"No block token matched line {i}: {lines[i]!r}")
+
+
+class InlineToken(Token):
+    subclasses = []
+
+    def __init_subclass__(cls):
+        InlineToken.subclasses.append(cls)
+
+    @classmethod
+    def parse(_, line: str, i: int) -> tuple["InlineToken", int]:
+        for cls in InlineToken.subclasses:
+            token, i = cls.parse(line, i)
+            if token:
+                return token, i
+        raise Exception(f"No inline token matched character {i}: {line[i:]!r}")
+
+
+@dataclass
+class Document(Token):
+    children: list[BlockToken]
+
+    @classmethod
+    def parse(cls, lines: list[str]) -> "Document":
+        children = []
+        i = 0
+        while i < len(lines):
+            token, i = BlockToken.parse(lines, i)
+            children.append(token)
+        return Document(children)
+
+    def render(self, context: Context):
+        return "".join([x.render(context) for x in self.children])
+
+    def metadata(self):
+        title = None
+        description = None
+        context = Context()
+        for child in self.children:
+            if isinstance(child, Heading) and child.level == 1 and not title:
+                title = child.text.render(context)
+            if isinstance(child, Paragraph) and not description:
+                description = " ".join([x.render(context) for x in child.paragraph_lines])
+            if title and description:
+                break
+        if not title:
+            raise Exception("No title found")
+        if not description:
+            raise Exception("No description found")
+        return Metadata(title, description)
+
+
+@dataclass
+class Span(Token):
+    children: list[InlineToken]
+
+    @classmethod
+    def parse(cls, line: str) -> "Span":
+        children = []
+        i = 0
+        while i < len(line):
+            token, i = InlineToken.parse(line, i)
+            children.append(token)
+        return Span(children)
+
+    def render(self, context: Context):
+        return "".join([x.render(context) for x in self.children])
+
+
+@dataclass
+class Directive(BlockToken):
+    directive: str
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^:([a-zA-Z_][a-zA-Z0-9_]*):$")
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["Directive"], int]:
+        match = Directive.opening_re().match(lines[i].strip())
+        if not match:
+            return None, i
+        return Directive(match.group(1)), i + 1
+
+    def render(self, context: Context):
+        func = context.__class__.__dict__.get(self.directive)
+        if not inspect.isfunction(func):
+            raise Exception(f"Could not find function in context: {self.directive}")
+        return getattr(context, self.directive)()
+
+
+class BlankLine(BlockToken):
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["BlankLine"], int]:
+        return (BlankLine(), i + 1) if lines[i].strip() == "" else (None, i)
+
+    def render(self, context: Context):
+        return ""
+
+
+@dataclass
+class CodeBlock(BlockToken):
+    language: Optional[str]
+    code_lines: list[str]
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^(`{3,})([A-Za-z0-9_-]+)?$")
+
+    @classmethod
+    def closing_re(cls, fence) -> re.Pattern[str]:
+        return re.compile(rf"^{fence}$")
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["CodeBlock"], int]:
+        match = CodeBlock.opening_re().match(lines[i])
+        if not match:
+            return None, i
+        fence = match.group(1)
+        language = match.group(2)
+        code_lines = []
+        closing_re = CodeBlock.closing_re(fence)
+        j = i + 1
+        while j < len(lines):
+            if closing_re.match(lines[j]):
+                return CodeBlock(language, code_lines), j + 1
+            code_lines.append(lines[j])
+            j += 1
+        return None, i
+
+    def render(self, context: Context):
+        code = "\n".join([escape(x, quote=True) for x in self.code_lines])
+        if self.language:
+            language_class = f' class="language-{escape(self.language, quote=True)}"'
+        else:
+            language_class = ""
+        return f'<pre><code{language_class}>{code}</code></pre>'
+
+
+class HorizontalRule(BlockToken):
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^\s*---+\s*$")
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["HorizontalRule"], int]:
+        return (HorizontalRule(), i + 1) if HorizontalRule.opening_re().match(lines[i]) else (None, i)
+
+    def render(self, context: Context):
+        return "<hr>"
+
+
+@dataclass
+class Heading(BlockToken):
+    text: Span
+    level: int
+    center: bool
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^(#{1,6})\s+(.+?)\s*( #{,6})?$")
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["Heading"], int]:
+        match = Heading.opening_re().match(lines[i])
+        if not match:
+            return None, i
+        text = Span.parse(match.group(2).strip())
+        level = len(match.group(1))
+        center = ((match.group(3) or "").strip() == match.group(1))
+        return Heading(text, level, center), i + 1
+
+    def render(self, context: Context):
+        cls = ' class="center"' if self.center else ""
+        return f"<h{self.level}{cls}>{self.text.render(context)}</h{self.level}>"
+
+
+@dataclass
+class List(BlockToken):
+    ordered: bool
+    items: list[Document]
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^( [-#] )(.*)$")
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["List"], int]:
+        match = List.opening_re().match(lines[i])
+        if not match:
+            return None, i
+        marker = match.group(1)
+        inner_lines = [match.group(2)]
+        items = []
+        j = i + 1
+        while j < len(lines):
+            if lines[j].strip() == "" or lines[j][:3] == "   ":
+                inner_lines.append(lines[j][3:])
+                j += 1
+            elif lines[j][:3] == marker:
+                items.append(Document.parse(inner_lines))
+                inner_lines = [lines[j][3:]]
+                j += 1
+            else:
+                break
+        items.append(Document.parse(inner_lines))
+        return List("#" in marker, items), j
+
+    def render(self, context: Context):
+        tag = "ol" if self.ordered else "ul"
+        items = "".join([f"<li>{item.render(context)}</li>" for item in self.items])
+        return f"<{tag}>{items}</{tag}>"
+
+
+@dataclass
+class BlockQuote(BlockToken):
+    document: Document
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["BlockQuote"], int]:
+        if not lines[i].startswith("> "):
+            return None, i
+        j = i + 1
+        while j < len(lines) and lines[j].startswith("> "):
+            j += 1
+        return BlockQuote(Document.parse([line[2:] for line in lines[i:j]])), j
+
+    def render(self, context: Context):
+        return f"<blockquote>{self.document.render(context)}</blockquote>"
+
+
+@dataclass
+class Paragraph(BlockToken):
+    paragraph_lines: list[Span]
+    align: str
+
+    @classmethod
+    def is_other_block_token(_, lines: list[str], i: int) -> bool:
+        for cls in BlockToken.subclasses:
+            if cls != Paragraph:
+                token, i = cls.parse(lines, i)
+                if token:
+                    return True
+        return False
+
+    @classmethod
+    def parse(cls, lines: list[str], i: int) -> tuple[Optional["Paragraph"], int]:
+        alignments = ("center", "left", "right")
+        align = ""
+        paragraph_lines = []
+        j = i
+        while j < len(lines):
+            if Paragraph.is_other_block_token(lines, j):
+                break
+            line = lines[j].strip()
+            if i == j:
+                for alignment in alignments:
+                    marker = f"{alignment}:"
+                    if line.startswith(marker):
+                        align = alignment
+                        line = line[len(marker):].strip()
+                        break
+            paragraph_lines.append(Span.parse(line))
+            j += 1
+        return (Paragraph(paragraph_lines, align), j) if paragraph_lines else (None, i)
+
+    def render(self, context: Context):
+        text = " ".join([x.render(context) for x in self.paragraph_lines])
+        align_class = (f' class="{self.align}"' if self.align else "")
+        return f'<p{align_class}>{text}</p>'
+
+
+@dataclass
+class Bold(InlineToken):
+    text: Span
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^\*[A-Za-z0-9]$")
+
+    @classmethod
+    def closing_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^[A-Za-z0-9]\*$")
+
+    @classmethod
+    def parse(cls, line: str, i: int) -> tuple[Optional["Bold"], int]:
+        if not Bold.opening_re().match(line[i:i+2]):
+            return None, i
+        closing_re = Bold.closing_re()
+        j = i + 1
+        while j + 1 < len(line):
+            if closing_re.match(line[j:j+2]):
+                return Bold(Span.parse(line[i+1:j+1])), j + 2
+            j += 1
+        return None, i
+
+    def render(self, context: Context):
+        return f"<strong>{self.text.render(context)}</strong>"
+
+
+@dataclass
+class InlineCode(InlineToken):
+    code: str
+
+    @classmethod
+    def is_fence(cls, line: str, start: int, fence_length: int) -> bool:
+        end = start + fence_length
+        return line[start:end] == "`" * fence_length
+
+    @classmethod
+    def parse(cls, line: str, i: int) -> tuple[Optional["InlineCode"], int]:
+        fence_length = 0
+        while InlineCode.is_fence(line, i, fence_length + 1):
+            fence_length += 1
+        if fence_length == 0:
+            return None, i
+        j = i + fence_length
+        while j + fence_length <= len(line):
+            if InlineCode.is_fence(line, j, fence_length):
+                start = i + fence_length
+                return InlineCode(line[start:j]), j + fence_length
+            j += 1
+        return None, i
+
+    def render(self, context: Context):
+        return f"<code>{escape(self.code, quote=True)}</code>"
+
+
+@dataclass
+class Link(InlineToken):
+    text: Span
+    href: str
+    button: bool
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^([\[{][^}\]]+[}\]])\(([^)]+)\)")
+
+    @classmethod
+    def parse(cls, line: str, i: int) -> tuple[Optional["Link"], int]:
+        match = Link.opening_re().match(line[i:])
+        if not match:
+            return None, i
+        text = match.group(1)
+        if (text[0] == '[') != (text[-1] == ']'):
+            return None, i
+        button = (text[0] == '{')
+        text = Span.parse(text[1:-1].strip())
+        href = match.group(2)
+        end = i + len(match.group(0))
+        return Link(text, href, button), end
+
+    def render(self, context: Context):
+        if not is_safe_href(self.href):
+            raise Exception(f"Unsafe href: {self.href}")
+        button_class = (' class="button"' if self.button else "")
+        return f'<a href="{escape(self.href, quote=True)}"{button_class}>{self.text.render(context)}</a>'
+
+
+@dataclass
+class URL(InlineToken):
+    href: str
+
+    @classmethod
+    def opening_re(cls) -> re.Pattern[str]:
+        return re.compile(r"^https?://[^\s<>\[\]()]+")
+
+    @classmethod
+    def parse(cls, line: str, i: int) -> tuple[Optional["URL"], int]:
+        match = URL.opening_re().match(line[i:])
+        if not match:
+            return None, i
+        href = match.group(0)
+        return URL(href), i + len(href)
+
+    def render(self, context: Context):
+        if not is_safe_href(self.href):
+            raise Exception(f"Unsafe href: {self.href}")
+        href = escape(self.href, quote=True)
+        return f'<a href="{href}">{href}</a>'
+
+
+@dataclass
+class Text(InlineToken):
+    value: str
+
+    @classmethod
+    def is_other_inline_token(_, line: str, i: int) -> bool:
+        for cls in InlineToken.subclasses:
+            if cls != Text:
+                token, i = cls.parse(line, i)
+                if token:
+                    return True
+        return False
+
+    @classmethod
+    def parse(cls, line: str, i: int) -> tuple[Optional["Text"], int]:
+        value = ""
+        j = i
+        while j < len(line):
+            if Text.is_other_inline_token(line, j):
+                break
+            value += line[j]
+            j += 1
+        return (Text(value), j) if value else (None, i)
+
+    def render(self, context: Context):
+        value = escape(self.value, quote=True)
+        return value
+
+
+def metadata(source: str, context: Context = Context()) -> Metadata:
+    lines = source.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    return Document.parse(lines).metadata()
+
+
+def render(source: str, context: Context = Context()) -> str:
+    lines = source.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    return Document.parse(lines).render(context)
+
+
+def is_safe_href(href: str) -> bool:
+    href = href.strip()
+    parsed = urlparse(href)
+    return (not parsed.scheme) or (parsed.scheme.lower() in SAFE_SCHEMES)

mymarkup-0.1.0/src/mymarkup/styles.css

@@ -0,0 +1,246 @@
+:root {
+  --bg: #060816;
+  --bg-2: #0b1224;
+  --fg: #e6eefc;
+  --muted: #8fa2c9;
+  --border: rgba(122, 162, 255, 0.2);
+  --surface: rgba(12, 18, 36, 0.74);
+  --surface-2: rgba(21, 29, 56, 0.92);
+  --surface-3: rgba(79, 124, 255, 0.12);
+  --link: #7dd3fc;
+  --link-hover: #c084fc;
+  --glow: rgba(96, 165, 250, 0.22);
+  --code-bg: #0a1022;
+  --code-fg: #dbeafe;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  background: var(--bg);
+  color: var(--fg);
+  font: 1.05rem/1.75 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background-image:
+    radial-gradient(circle at top left, rgba(56, 189, 248, 0.14), transparent 30rem),
+    radial-gradient(circle at top right, rgba(168, 85, 247, 0.14), transparent 24rem),
+    linear-gradient(180deg, #0a1022 0%, #060816 100%);
+}
+
+.site-shell {
+  position: relative;
+  max-width: 86rem;
+  margin: 0 auto;
+  padding: 3rem 1.25rem 4rem;
+}
+
+.site-frame {
+  position: relative;
+  max-width: 72ch;
+  margin: 0 auto;
+  border: 1px solid var(--border);
+  border-radius: 1.4rem;
+  background: linear-gradient(180deg, rgba(12, 18, 36, 0.9), rgba(8, 12, 26, 0.92));
+  box-shadow:
+    0 0 0 1px rgba(255, 255, 255, 0.03) inset,
+    0 30px 80px rgba(2, 8, 23, 0.65),
+    0 0 40px var(--glow);
+  backdrop-filter: blur(18px);
+}
+
+.site-content {
+  padding: 0.6rem 1.6rem 2rem;
+}
+
+.page-glow {
+  position: fixed;
+  z-index: 0;
+  pointer-events: none;
+  border-radius: 999px;
+  filter: blur(90px);
+  opacity: 0.7;
+}
+
+.page-glow-1 {
+  top: 3rem;
+  left: 2rem;
+  width: 18rem;
+  height: 18rem;
+  background: rgba(34, 211, 238, 0.18);
+}
+
+.page-glow-2 {
+  right: 4rem;
+  bottom: 3rem;
+  width: 20rem;
+  height: 20rem;
+  background: rgba(168, 85, 247, 0.16);
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 2rem 0 0.75rem;
+  line-height: 1.2;
+  letter-spacing: -0.03em;
+  color: #f8fbff;
+  text-shadow: 0 0 22px rgba(125, 211, 252, 0.08);
+}
+
+h1 { margin-top: 0; font-size: clamp(2.4rem, 6vw, 3.4rem); }
+h2 { font-size: 1.85rem; }
+h3 { font-size: 1.4rem; }
+
+p, ul, ol, pre, blockquote, table, hr { margin: 1.1rem 0; }
+ul, ol { padding-left: 1.4rem; }
+li + li { margin-top: 0.35rem; }
+li > p { margin: 0.3rem 0; }
+
+a, a:visited {
+  color: var(--link);
+  text-underline-offset: 0.16em;
+  text-decoration-thickness: 0.08em;
+  transition: color 140ms ease, text-shadow 140ms ease, border-color 140ms ease, background 140ms ease, transform 140ms ease;
+}
+
+a:hover {
+  color: var(--link-hover);
+  text-shadow: 0 0 16px rgba(192, 132, 252, 0.28);
+}
+
+a.button, a.button:visited {
+  display: inline-block;
+  margin: 0.25rem 0.35rem 0.25rem 0;
+  padding: 0.55rem 0.85rem;
+  border: 1px solid rgba(125, 211, 252, 0.3);
+  border-radius: 0.8rem;
+  background: linear-gradient(180deg, rgba(17, 24, 39, 0.96), rgba(13, 20, 38, 0.92));
+  color: #dbeafe;
+  font-weight: 600;
+  text-decoration: none;
+  box-shadow:
+    0 0 0 1px rgba(255, 255, 255, 0.03) inset,
+    0 10px 24px rgba(2, 8, 23, 0.35);
+}
+
+a.button:hover {
+  background: linear-gradient(180deg, rgba(25, 35, 63, 0.98), rgba(16, 24, 46, 0.95));
+  text-decoration: none;
+  transform: translateY(-1px);
+}
+
+a.button:active {
+  transform: translateY(1px);
+}
+
+a.button:focus-visible {
+  outline: 2px solid rgba(125, 211, 252, 0.5);
+  outline-offset: 2px;
+}
+
+code {
+  padding: 0.12rem 0.35rem;
+  border-radius: 0.35rem;
+  background: rgba(125, 211, 252, 0.1);
+  color: #bfdbfe;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 0.92em;
+}
+
+pre {
+  overflow-x: auto;
+  padding: 1rem 1.1rem;
+  border-radius: 0.9rem;
+  border: 1px solid rgba(125, 211, 252, 0.12);
+  background:
+    linear-gradient(180deg, rgba(14, 21, 42, 0.98), rgba(7, 12, 24, 0.98));
+  color: var(--code-fg);
+  box-shadow:
+    0 16px 40px rgba(2, 8, 23, 0.42),
+    0 0 24px rgba(96, 165, 250, 0.08);
+}
+
+pre code {
+  padding: 0;
+  background: transparent;
+  color: inherit;
+  font-size: 0.95rem;
+}
+
+blockquote {
+  padding: 0.2rem 0 0.2rem 1rem;
+  border-left: 0.28rem solid #7dd3fc;
+  border-radius: 0 1rem 1rem 0;
+  background: rgba(125, 211, 252, 0.06);
+  color: #c7d2fe;
+  box-shadow: inset 0 0 0 1px rgba(125, 211, 252, 0.08);
+}
+
+blockquote > :first-child { margin-top: 0.6rem; }
+blockquote > :last-child { margin-bottom: 0.6rem; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  overflow: hidden;
+  border: 1px solid rgba(125, 211, 252, 0.14);
+  border-radius: 1rem;
+  background: rgba(12, 18, 36, 0.55);
+  box-shadow: 0 18px 42px rgba(2, 8, 23, 0.32);
+}
+
+td, th {
+  padding: 0.65rem 0.75rem;
+  text-align: left;
+  vertical-align: top;
+  border-bottom: 1px solid var(--border);
+}
+
+th {
+  background: linear-gradient(180deg, rgba(125, 211, 252, 0.12), rgba(96, 165, 250, 0.06));
+  color: #e0f2fe;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-size: 0.78rem;
+}
+
+td:first-child { width: 34%; font-weight: 600; }
+
+hr {
+  border: 0;
+  border-top: 1px solid rgba(125, 211, 252, 0.16);
+  box-shadow: 0 0 16px rgba(125, 211, 252, 0.12);
+}
+
+img {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  margin: 1.5rem auto;
+  border: 1px solid rgba(125, 211, 252, 0.16);
+  border-radius: 1rem;
+  box-shadow:
+    0 20px 42px rgba(2, 8, 23, 0.4),
+    0 0 30px rgba(96, 165, 250, 0.08);
+}
+
+.breadcrumbs {
+  margin-bottom: 1.5rem;
+  color: var(--muted);
+  font-size: 0.82rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.breadcrumbs a, .breadcrumbs a:visited {
+  color: #c4b5fd;
+  text-decoration: none;
+}
+
+.breadcrumbs a:hover {
+  color: #e9d5ff;
+}
+
+.center { text-align: center; }
+.left { text-align: left; }
+.right { text-align: right; }

mymarkup-0.1.0/src/mymarkup/template.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>TITLE</title>
+    <meta name="color-scheme" content="dark">
+    <link rel="stylesheet" href="/styles.css">
+  </head>
+  <body>
+    <div class="page-glow page-glow-1"></div>
+    <div class="page-glow page-glow-2"></div>
+    <main class="site-shell">
+      <div class="site-frame">
+        <article class="site-content">
+          MARKUP
+        </article>
+      </div>
+    </main>
+  </body>
+</html>

mymarkup-0.1.0/src/mymarkup/tests.py

@@ -0,0 +1,324 @@
+from textwrap import dedent
+
+from .mymarkup import render
+
+
+def test_headings():
+    assert render("# Heading 1") == "<h1>Heading 1</h1>"
+    assert render("## Heading 2") == "<h2>Heading 2</h2>"
+    assert render("### Heading 3") == "<h3>Heading 3</h3>"
+
+    assert render("# Heading 1 #") == '<h1 class="center">Heading 1</h1>'
+    assert render("## Heading 2 ##") == '<h2 class="center">Heading 2</h2>'
+    assert render("### Heading 3 ###") == '<h3 class="center">Heading 3</h3>'
+
+    assert render("#Not a heading") == "<p>#Not a heading</p>"
+
+    assert render("# Heading with *bold*") == (
+        "<h1>Heading with <strong>bold</strong></h1>"
+    )
+
+    assert render("# Heading with `code`") == (
+        "<h1>Heading with <code>code</code></h1>"
+    )
+
+    assert render("# Heading with [link](https://example.com)") == (
+        '<h1>Heading with <a href="https://example.com">link</a></h1>'
+    )
+
+
+def test_paragraphs():
+    assert render(
+        dedent("""
+            Line one
+            Line two
+        """).strip()
+    ) == "<p>Line one Line two</p>"
+
+    assert render(
+        dedent("""
+            First paragraph
+
+            Second paragraph
+        """).strip()
+    ) == "<p>First paragraph</p><p>Second paragraph</p>"
+
+
+def test_lists():
+    assert render(" - item 1\n - item 2") == "<ul><li><p>item 1</p></li><li><p>item 2</p></li></ul>"
+
+    assert render(" # First\n # Second\n # Third") == "<ol><li><p>First</p></li><li><p>Second</p></li><li><p>Third</p></li></ol>"
+
+    assert render(" item\n\n #item") == "<p>item</p><p>#item</p>"
+
+    assert render(" - item with *bold*") == (
+        "<ul><li><p>item with <strong>bold</strong></p></li></ul>"
+    )
+
+    assert render(" - item with `code`") == (
+        "<ul><li><p>item with <code>code</code></p></li></ul>"
+    )
+
+    assert render(" - item with [link](https://example.com)") == (
+        '<ul><li><p>item with <a href="https://example.com">link</a></p></li></ul>'
+    )
+
+
+def test_nested_lists():
+    assert render(
+        dedent("""
+        test
+         - Parent
+            - Child
+               - Grandchild
+        """).strip()
+    ) == (
+        "<p>test</p><ul><li><p>Parent</p>"
+        "<ul><li><p>Child</p>"
+        "<ul><li><p>Grandchild</p></li></ul>"
+        "</li></ul>"
+        "</li></ul>"
+    )
+
+
+def test_mixed_lists():
+    assert render(
+        dedent("""
+        test
+         - Item
+            # Step one
+            # Step two
+         - Item two
+        """).strip()
+    ) == (
+        "<p>test</p><ul><li><p>Item</p>"
+        "<ol><li><p>Step one</p></li><li><p>Step two</p></li></ol>"
+        "</li><li><p>Item two</p></li></ul>"
+    )
+
+
+def test_list_item_continuation():
+    assert render(
+        dedent("""
+        test
+         - This is a list item
+           continued here
+           and continued here
+         - and this is the next item
+        """).strip()
+    ) == "<p>test</p><ul><li><p>This is a list item continued here and continued here</p></li><li><p>and this is the next item</p></li></ul>"
+
+
+def test_inline_markup():
+    assert render("*bold*") == "<p><strong>bold</strong></p>"
+
+    assert render("*bold and `code` inside*") == (
+        "<p><strong>bold and <code>code</code> inside</strong></p>"
+    )
+
+    assert render("`*not bold* [not a link]`") == (
+        "<p><code>*not bold* [not a link]</code></p>"
+    )
+
+    assert render("word*bold*") == "<p>word<strong>bold</strong></p>"
+    assert render("*bold*word") == "<p><strong>bold</strong>word</p>"
+    assert render("word*bold*word") == "<p>word<strong>bold</strong>word</p>"
+
+    assert render("word *bold*") == "<p>word <strong>bold</strong></p>"
+    assert render("*bold* word") == "<p><strong>bold</strong> word</p>"
+    assert render("word *bold* word") == (
+        "<p>word <strong>bold</strong> word</p>"
+    )
+
+    assert render("*") == "<p>*</p>"
+    assert render("**") == "<p>**</p>"
+    assert render("***") == "<p>***</p>"
+    assert render("* *") == "<p>* *</p>"
+
+    assert render("*bold `code` [link](link.html) test*") == (
+        '<p><strong>bold <code>code</code> '
+        '<a href="link.html">link</a> test</strong></p>'
+    )
+
+    assert render("[*bold link*](https://example.com)") == (
+        '<p><a href="https://example.com">'
+        '<strong>bold link</strong>'
+        "</a></p>"
+    )
+
+    assert render("[`code link`](https://example.com)") == (
+        '<p><a href="https://example.com">'
+        "<code>code link</code>"
+        "</a></p>"
+    )
+
+    assert render("[link](link.html) and *bold* and `code`") == (
+        '<p><a href="link.html">link</a> '
+        "and <strong>bold</strong> "
+        "and <code>code</code></p>"
+    )
+
+    assert render("*bold.*") == "<p>*bold.*</p>"
+    assert render("(*bold*)") == "<p>(<strong>bold</strong>)</p>"
+    assert render("word (*bold*) word") == (
+        "<p>word (<strong>bold</strong>) word</p>"
+    )
+    assert render("*bold*,") == "<p><strong>bold</strong>,</p>"
+    assert render("*bold*!") == "<p><strong>bold</strong>!</p>"
+    assert render("*bold*?") == "<p><strong>bold</strong>?</p>"
+    assert render("*bold*.") == "<p><strong>bold</strong>.</p>"
+
+    assert render("word*bold*.") == "<p>word<strong>bold</strong>.</p>"
+    assert render("(*bold*word)") == "<p>(<strong>bold</strong>word)</p>"
+    assert render("(word*bold*)") == "<p>(word<strong>bold</strong>)</p>"
+
+    assert render("Use `foo_bar()` here") == (
+        "<p>Use <code>foo_bar()</code> here</p>"
+    )
+
+    assert render("Call `obj.method()`.") == (
+        "<p>Call <code>obj.method()</code>.</p>"
+    )
+
+    assert render("prefix`code`suffix") == (
+        "<p>prefix<code>code</code>suffix</p>"
+    )
+
+    assert render("`not closed") == "<p>`not closed</p>"
+
+
+def test_empty_or_invalid_inline_markup():
+    assert render("**") == "<p>**</p>"
+    assert render("``") == "<p>``</p>"
+    assert render("[link]()") == "<p>[link]()</p>"
+    assert render("*not bold") == "<p>*not bold</p>"
+
+
+def test_regular_links():
+    assert render("[Example](https://example.com)") == (
+        '<p><a href="https://example.com">Example</a></p>'
+    )
+    assert render("[Wiki page](wiki-page.html)") == (
+        '<p><a href="wiki-page.html">Wiki page</a></p>'
+    )
+
+
+def test_bare_urls():
+    assert render(
+        dedent("""
+            https://example.com
+        """).strip()
+    ) == (
+        '<p><a href="https://example.com">'
+        "https://example.com"
+        "</a></p>"
+    )
+
+
+def test_images():
+    assert render("[https://example.com/image.png]") == (
+        '<p><img src="https://example.com/image.png"></p>'
+    )
+
+    assert render("[/images/cat.webp]") == (
+        '<p><img src="/images/cat.webp"></p>'
+    )
+
+    assert render("[cat.svg]") == '<p><img src="cat.svg"></p>'
+
+
+def test_fenced_code_blocks():
+    assert render(
+        dedent("""
+            ```
+            print("hello")
+            ```
+        """).strip()
+    ) == dedent("""
+        <pre><code>print(&quot;hello&quot;)</code></pre>
+    """).strip()
+
+    assert render(
+        dedent("""
+            ```python
+            print("hello")
+            print("hello")
+            ```
+        """).strip()
+    ) == dedent("""
+        <pre><code class="language-python">print(&quot;hello&quot;)
+        print(&quot;hello&quot;)</code></pre>
+    """).strip()
+
+
+def test_variable_length_code_fences():
+    assert render(
+        dedent("""
+            ````markdown
+            ```
+            nested code fence
+            ```
+            ````
+        """).strip()
+    ) == dedent("""
+        <pre><code class="language-markdown">```
+        nested code fence
+        ```</code></pre>
+    """).strip()
+
+
+def test_horizontal_rules():
+    assert render("---") == "<hr>"
+    assert render("-----") == "<hr>"
+
+
+def test_blockquotes():
+    assert render("> quoted text") == (
+        "<blockquote><p>quoted text</p></blockquote>"
+    )
+
+    assert render(
+        dedent("""
+            > quoted line one
+            > quoted line two
+        """).strip()
+    ) == (
+        "<blockquote><p>"
+        "quoted line one quoted line two"
+        "</p></blockquote>"
+    )
+
+
+def test_xss():
+    assert render("<script>alert(1)</script>") == (
+        "<p>&lt;script&gt;alert(1)&lt;/script&gt;</p>"
+    )
+    assert render('[x](" onclick="alert(1)') == '<p><a href="&quot; onclick=&quot;alert(1">x</a></p>'
+    assert render("[example](https://example.com?q=<script>)") == (
+        '<p><a href="https://example.com?q=&lt;script&gt;">example</a></p>'
+    )
+
+
+def main():
+    test_headings()
+    test_paragraphs()
+    test_lists()
+    test_nested_lists()
+    test_mixed_lists()
+    test_list_item_continuation()
+    test_inline_markup()
+    test_empty_or_invalid_inline_markup()
+    test_regular_links()
+    test_bare_urls()
+    # test_images()
+    test_fenced_code_blocks()
+    test_variable_length_code_fences()
+    test_horizontal_rules()
+    test_blockquotes()
+    test_xss()
+
+    print("All tests passed")
+
+
+if __name__ == "__main__":
+    main()

mymarkup-0.1.0/src/mymarkup.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: mymarkup
+Version: 0.1.0
+Summary: mymarkup package
+Requires-Python: >=3.9

mymarkup-0.1.0/src/mymarkup.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+src/mymarkup/__init__.py
+src/mymarkup/__main__.py
+src/mymarkup/mymarkup.py
+src/mymarkup/styles.css
+src/mymarkup/template.html
+src/mymarkup/tests.py
+src/mymarkup.egg-info/PKG-INFO
+src/mymarkup.egg-info/SOURCES.txt
+src/mymarkup.egg-info/dependency_links.txt
+src/mymarkup.egg-info/entry_points.txt
+src/mymarkup.egg-info/top_level.txt

mymarkup-0.1.0/src/mymarkup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mymarkup-0.1.0/src/mymarkup.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mymarkup = mymarkup.__main__:main

mymarkup-0.1.0/src/mymarkup.egg-info/top_level.txt

@@ -0,0 +1 @@
+mymarkup