solid-mds 0.3.2

package/LICENSE

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

package/README.md

@@ -0,0 +1,476 @@
+# solid-mds
+
+A SolidJS library for parsing and rendering MDS (Markdown Steps) format — an
+extended Markdown syntax designed for step-based content like slide decks,
+tutorials, and wizards.
+
+## Installation
+
+```bash
+npm install solid-mds
+# or
+pnpm add solid-mds
+```
+
+**Peer dependency:** This library requires SolidJS ^1.9.0
+
+## Quick Start
+
+```tsx
+import { parse } from "solid-mds";
+
+const markdown = `
+# Hello World
+
+This is **bold** and *italic* text.
+`;
+
+function App() {
+  const result = parse(markdown);
+  return <div>{result.steps.default.body}</div>;
+}
+```
+
+## Opinionated Plugin Configuration
+
+solid-mds comes pre-configured with an opinionated set of remark/rehype plugins:
+
+- **[remark-gfm](https://github.com/remarkjs/remark-gfm)** — GitHub Flavored
+  Markdown (tables, strikethrough, autolinks, task lists)
+- **[remark-math](https://github.com/remarkjs/remark-math)** +
+  **[rehype-katex](https://github.com/remarkjs/rehype-katex)** — LaTeX math
+  rendering
+
+These plugins are always enabled and cannot be configured. This ensures
+consistent rendering across all use cases.
+
+**Note:** To display math properly, include the KaTeX CSS in your app:
+
+```html
+<link
+  rel="stylesheet"
+  href="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/katex.min.css"
+/>
+```
+
+## Supported Markdown Features
+
+### Standard Markdown
+
+```markdown
+# Heading 1
+
+## Heading 2
+
+### Heading 3
+
+**bold** and _italic_ and ~~strikethrough~~
+
+- Unordered list
+- Another item
+
+1. Ordered list
+2. Second item
+
+> Blockquotes
+
+`inline code`
+
+[Links](https://example.com)
+
+![Images](image.png)
+```
+
+### GFM Extensions
+
+#### Tables
+
+```markdown
+| Header 1 | Header 2 |
+| -------- | -------- |
+| Cell 1   | Cell 2   |
+| Cell 3   | Cell 4   |
+```
+
+#### Task Lists
+
+```markdown
+- [x] Completed task
+- [ ] Incomplete task
+```
+
+#### Autolinks
+
+```markdown
+Visit https://example.com automatically linked.
+```
+
+### Math (LaTeX)
+
+#### Inline Math
+
+```markdown
+The equation $E = mc^2$ is famous.
+```
+
+#### Block Math
+
+```markdown
+$$
+\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}
+$$
+```
+
+## MDS Format: Steps
+
+MDS extends Markdown with a step-based structure using `+++stepId` separators:
+
+```markdown
++++intro
+# Welcome
+
+This is the introduction step.
+
++++
+
+main
+
+# Main Content
+
+This is the main step.
+
++++conclusion
+
+# Summary
+
+This is the conclusion.
+```
+
+### Parsing Steps
+
+```tsx
+import { parse } from "solid-mds";
+
+const result = parse(markdown);
+
+// result.first → "intro" (first step ID)
+// result.count → 3 (number of steps)
+// result.steps.intro.body → JSX.Element
+// result.steps.intro.next → "main"
+// result.steps.main.prev → "intro"
+// result.steps.main.next → "conclusion"
+// result.steps.conclusion.prev → "main"
+// result.steps.conclusion.next → null
+```
+
+### Step Object Structure
+
+Each step contains:
+
+```ts
+interface Step {
+  id: string; // Step identifier
+  body: JSX.Element; // Rendered markdown content
+  local: object; // Local metadata (see below)
+  prev: string | null; // Previous step ID
+  next: string | null; // Next step ID
+  current: number; // 1-based position
+}
+```
+
+## Metadata Blocks
+
+### Local Metadata (per step)
+
+Use ` ```@| ` blocks to define key-value metadata for a step:
+
+````markdown
++++slide1
+
+```@|
+title: Introduction
+speaker: John Doe
+```
+
+# Welcome to the Presentation
+````
+
+Access via `result.steps.slide1.local.title`.
+
+### Local Markdown Blocks
+
+Use ` ```@/name ` to define named markdown content within a step:
+
+````markdown
++++slide1
+
+```@/notes
+These are speaker notes with **formatting**.
+```
+
+# Main Slide Content
+````
+
+Access via `result.steps.slide1.local.notes` (returns `JSX.Element`).
+
+### Global Metadata
+
+Use ` ```@@| ` for document-wide metadata:
+
+````markdown
+```@@|
+author: Jane Smith
+version: 1.0
+```
+
++++first
+
+# First Step
+````
+
+Access via `result.global.author`.
+
+### Global Markdown Blocks
+
+Use ` ```@@/name ` for global named markdown content:
+
+````markdown
+```@@/footer
+Made with ❤️ by **Our Team**
+```
+
++++first
+
+# Content
+````
+
+Access via `result.global.footer` (returns `JSX.Element`).
+
+## Custom Components
+
+Override default HTML elements or create custom block components:
+
+### Override Standard Elements
+
+```tsx
+import {
+  parse,
+  ComponentMap,
+  StandardComponentProps,
+} from "solid-mds";
+
+const CustomHeading = (props: StandardComponentProps) => (
+  <h1 class="text-4xl font-bold text-blue-600">{props.children}</h1>
+);
+
+const components: ComponentMap = {
+  h1: CustomHeading,
+};
+
+const result = parse(markdown, components);
+```
+
+### Custom Blocks
+
+Create custom components that receive special props from code blocks:
+
+```tsx
+import { parse, ComponentMap, CustomBlockProps } from "solid-mds";
+
+// Define a custom component
+const Alert = (props: CustomBlockProps) => (
+  <div class={`alert alert-${props.payload[0] || "info"}`}>
+    {props.children}
+  </div>
+);
+
+const components: ComponentMap = {
+  alert: Alert,
+};
+
+const markdown = `
+\`\`\`alert/warning
+This is a **warning** message!
+\`\`\`
+`;
+
+const result = parse(markdown, components);
+```
+
+The code block ` ```slert/warning ` will render using your `Alert` component
+with:
+
+- `props.payload` → `["warning"]` (path segments after component name)
+- `props.raw` → `"This is a **warning** message!"` (raw content as string if you
+  need it)
+- `props.children` → Rendered markdown as JSX
+
+### Custom Blocks with Data
+
+Use the `|` suffix for YAML data instead of markdown content:
+
+```tsx
+const Card = (props: CustomBlockProps) => (
+  <div class="card">
+    <h2>{props.data?.title}</h2>
+    <p>{props.data?.description}</p>
+  </div>
+);
+
+const components: ComponentMap = { Card };
+
+const markdown = `
+\`\`\`Card|
+title: My Card Title
+description: This is the card description
+\`\`\`
+`;
+
+const result = parse(markdown, components);
+```
+
+With ` ```Card| `, the content is parsed as YAML and available via `props.data`.
+
+## Complete Example
+
+```tsx
+import { createSignal, Show, For } from "solid-js";
+import {
+  parse,
+  ComponentMap,
+  CustomBlockProps,
+  StandardComponentProps,
+} from "solid-mds";
+
+// Custom components
+const Slide = (props: CustomBlockProps) => (
+  <div class="slide" data-layout={props.payload[0]}>
+    {props.children}
+  </div>
+);
+
+const Code = (props: StandardComponentProps) => (
+  <pre class="bg-gray-800 text-white p-4 rounded">
+    <code>{props.children}</code>
+  </pre>
+);
+
+const components: ComponentMap = {
+  Slide,
+  code: Code,
+};
+
+// Markdown content
+const content = `
+\`\`\`@@|
+title: My Presentation
+author: Developer
+\`\`\`
+
++++intro
+\`\`\`@|
+transition: fade
+\`\`\`
+
+# Welcome
+
+Introduction slide content.
+
++++demo
+\`\`\`Slide/centered
+# Demo Time
+
+Check out this code:
+
+\`\`\`js
+console.log("Hello!");
+\`\`\`
+\`\`\`
+
++++end
+# Thank You!
+
+Questions?
+`;
+
+function Presentation() {
+  const result = parse(content, components);
+  const [currentId, setCurrentId] = createSignal(result.first);
+
+  const currentStep = () => result.steps[currentId()!];
+
+  const goNext = () => {
+    const next = currentStep()?.next;
+    if (next) setCurrentId(next);
+  };
+
+  const goPrev = () => {
+    const prev = currentStep()?.prev;
+    if (prev) setCurrentId(prev);
+  };
+
+  return (
+    <div class="presentation">
+      <header>
+        <h1>{result.global?.title}</h1>
+        <span>by {result.global?.author}</span>
+      </header>
+
+      <main>
+        <Show when={currentStep()}>{currentStep().body}</Show>
+      </main>
+
+      <footer>
+        <button onClick={goPrev} disabled={!currentStep()?.prev}>
+          Previous
+        </button>
+        <span>
+          {currentStep()?.current} / {result.count}
+        </span>
+        <button onClick={goNext} disabled={!currentStep()?.next}>
+          Next
+        </button>
+      </footer>
+    </div>
+  );
+}
+```
+
+## API Reference
+
+### `parse<TGlobal, TLocal>(input: string, components?: ComponentMap): ParseResult`
+
+Parses MDS content and returns a structured result. Please provide proper types
+for your global and local scope to receive a properly typed result.
+
+**Parameters:**
+
+- `input` — The MDS/Markdown string to parse
+- `components` — Optional map of custom components
+
+**Returns:**
+
+```ts
+interface ParseResult<TGlobal, TLocal> {
+  first: string | null; // First step ID
+  steps: Record<string, Step<TLocal>>; // All steps by ID
+  count: number; // Total number of steps
+  global: TGlobal | null; // Global metadata
+}
+```
+
+### Type Exports
+
+```ts
+import type {
+  ComponentMap,
+  CustomBlockProps,
+  StandardComponentProps,
+  ParseResult,
+  Step,
+} from "solid-mds";
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { Component, JSX } from 'solid-js';
+
+/**
+ * Props for custom block components (code blocks with name/sub/path syntax)
+ */
+interface CustomBlockProps {
+    /** The path segments after the component name, e.g. ['substructure', 'subsub'] */
+    payload: string[];
+    /** The raw content of the code block as plain text */
+    raw: string;
+    /** Parsed YAML data when using componentName| syntax */
+    data?: Record<string, string | string[]>;
+    /** The markdown-rendered content as children */
+    children?: JSX.Element;
+}
+/**
+ * Standard component props for regular HTML elements
+ */
+interface StandardComponentProps {
+    children?: JSX.Element;
+    [key: string]: unknown;
+}
+type ComponentMap = {
+    [tagName: string]: Component<CustomBlockProps> | Component<StandardComponentProps>;
+};
+
+interface StepLocalBase {
+    [key: string]: unknown;
+}
+interface GlobalMetaBase {
+    [key: string]: unknown;
+}
+interface Step<TLocal = StepLocalBase> {
+    id: string;
+    local: TLocal;
+    /** Component function that renders the step body. Call it to get JSX: {step.Body()} */
+    Body: Component;
+    prev: string | null;
+    next: string | null;
+    current: number;
+}
+interface ParseResult<TGlobal = GlobalMetaBase, TLocal = StepLocalBase> {
+    first: string | null;
+    steps: Record<string, Step<TLocal>>;
+    count: number;
+    global: TGlobal | null;
+}
+declare function parse<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(input: string, components?: ComponentMap): ParseResult<TGlobal, TLocal>;
+
+export { type ComponentMap, type CustomBlockProps, type GlobalMetaBase, type ParseResult, type StandardComponentProps, type Step, type StepLocalBase, parse };

package/dist/index.jsx

@@ -0,0 +1,402 @@
+// src/index.tsx
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkRehype from "remark-rehype";
+import rehypeKatex from "rehype-katex";
+import { parse as parseYaml2 } from "yaml";
+
+// src/hast-to-solid.tsx
+function convertProperties(properties) {
+  if (!properties) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (key === "className") {
+      result.class = value;
+    } else if (key === "class") {
+      result.class = Array.isArray(value) ? value.join(" ") : value;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function renderElement(tagName, props, children) {
+  switch (tagName) {
+    case "p":
+      return <p {...props}>{children}</p>;
+    case "h1":
+      return <h1 {...props}>{children}</h1>;
+    case "h2":
+      return <h2 {...props}>{children}</h2>;
+    case "h3":
+      return <h3 {...props}>{children}</h3>;
+    case "h4":
+      return <h4 {...props}>{children}</h4>;
+    case "h5":
+      return <h5 {...props}>{children}</h5>;
+    case "h6":
+      return <h6 {...props}>{children}</h6>;
+    case "div":
+      return <div {...props}>{children}</div>;
+    case "span":
+      return <span {...props}>{children}</span>;
+    case "a":
+      return <a {...props}>{children}</a>;
+    case "strong":
+      return <strong {...props}>{children}</strong>;
+    case "b":
+      return <b {...props}>{children}</b>;
+    case "em":
+      return <em {...props}>{children}</em>;
+    case "i":
+      return <i {...props}>{children}</i>;
+    case "code":
+      return <code {...props}>{children}</code>;
+    case "pre":
+      return <pre {...props}>{children}</pre>;
+    case "blockquote":
+      return <blockquote {...props}>{children}</blockquote>;
+    case "ul":
+      return <ul {...props}>{children}</ul>;
+    case "ol":
+      return <ol {...props}>{children}</ol>;
+    case "li":
+      return <li {...props}>{children}</li>;
+    case "hr":
+      return <hr {...props} />;
+    case "br":
+      return <br {...props} />;
+    case "img":
+      return <img {...props} />;
+    case "table":
+      return <table {...props}>{children}</table>;
+    case "thead":
+      return <thead {...props}>{children}</thead>;
+    case "tbody":
+      return <tbody {...props}>{children}</tbody>;
+    case "tr":
+      return <tr {...props}>{children}</tr>;
+    case "th":
+      return <th {...props}>{children}</th>;
+    case "td":
+      return <td {...props}>{children}</td>;
+    case "del":
+      return <del {...props}>{children}</del>;
+    case "sup":
+      return <sup {...props}>{children}</sup>;
+    case "sub":
+      return <sub {...props}>{children}</sub>;
+    // GFM elements
+    case "input":
+      return <input {...props} />;
+    case "section":
+      return <section {...props}>{children}</section>;
+    // KaTeX math elements
+    case "math":
+      return <math {...props}>{children}</math>;
+    case "semantics":
+      return <semantics {...props}>{children}</semantics>;
+    case "mrow":
+      return <mrow {...props}>{children}</mrow>;
+    case "mi":
+      return <mi {...props}>{children}</mi>;
+    case "mo":
+      return <mo {...props}>{children}</mo>;
+    case "mn":
+      return <mn {...props}>{children}</mn>;
+    case "mfrac":
+      return <mfrac {...props}>{children}</mfrac>;
+    case "msup":
+      return <msup {...props}>{children}</msup>;
+    case "msub":
+      return <msub {...props}>{children}</msub>;
+    case "msubsup":
+      return <msubsup {...props}>{children}</msubsup>;
+    case "msqrt":
+      return <msqrt {...props}>{children}</msqrt>;
+    case "mroot":
+      return <mroot {...props}>{children}</mroot>;
+    case "munder":
+      return <munder {...props}>{children}</munder>;
+    case "mover":
+      return <mover {...props}>{children}</mover>;
+    case "munderover":
+      return <munderover {...props}>{children}</munderover>;
+    case "mtable":
+      return <mtable {...props}>{children}</mtable>;
+    case "mtr":
+      return <mtr {...props}>{children}</mtr>;
+    case "mtd":
+      return <mtd {...props}>{children}</mtd>;
+    case "mtext":
+      return <mtext {...props}>{children}</mtext>;
+    case "mspace":
+      return <mspace {...props}>{children}</mspace>;
+    case "annotation":
+      return <annotation {...props}>{children}</annotation>;
+    case "svg":
+      return <svg {...props}>{children}</svg>;
+    case "path":
+      return <path {...props} />;
+    case "line":
+      return <line {...props} />;
+    case "rect":
+      return <rect {...props} />;
+    case "circle":
+      return <circle {...props} />;
+    case "g":
+      return <g {...props}>{children}</g>;
+    case "defs":
+      return <defs {...props}>{children}</defs>;
+    case "clipPath":
+      return <clipPath {...props}>{children}</clipPath>;
+    case "use":
+      return <use {...props} />;
+    default:
+      return <div {...props}>{children}</div>;
+  }
+}
+function renderNode(node, components) {
+  if (node.type === "text") {
+    return node.value;
+  }
+  if (node.type === "element") {
+    const element = node;
+    const tagName = element.tagName;
+    const rawProps = convertProperties(element.properties);
+    const CustomComponent = components[tagName];
+    const childElements = element.children.length > 0 ? element.children.map((child) => renderNode(child, components)) : null;
+    if (CustomComponent) {
+      if (typeof rawProps.payload === "string" && typeof rawProps.raw === "string") {
+        const customBlockProps = {
+          payload: JSON.parse(rawProps.payload),
+          raw: rawProps.raw
+        };
+        if (typeof rawProps.data === "string") {
+          customBlockProps.data = JSON.parse(rawProps.data);
+        }
+        const Comp2 = CustomComponent;
+        return <Comp2 {...customBlockProps}>{childElements}</Comp2>;
+      }
+      const Comp = CustomComponent;
+      return <Comp {...rawProps}>{childElements}</Comp>;
+    }
+    return renderElement(tagName, rawProps, childElements);
+  }
+  return null;
+}
+function hastToSolidComponent(hastTree, components = {}) {
+  const treeData = hastTree;
+  const componentMap = components;
+  return function HastBody() {
+    const elements = treeData.children.map((node) => renderNode(node, componentMap));
+    return <>{elements}</>;
+  };
+}
+
+// src/remark-custom-blocks.ts
+import { visit } from "unist-util-visit";
+import { parse as parseYaml } from "yaml";
+function remarkCustomBlocks(options) {
+  const { components, processor } = options;
+  return (tree) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (!parent || index === void 0) return;
+      const lang = node.lang;
+      if (!lang) return;
+      const isDataBlock = lang.endsWith("|");
+      const cleanLang = isDataBlock ? lang.slice(0, -1) : lang;
+      const segments = cleanLang.split("/");
+      const componentName = segments[0];
+      const raw = node.value;
+      if (!components.has(componentName)) return;
+      const payload = segments.slice(1);
+      if (isDataBlock) {
+        const data = parseYaml(raw);
+        const customNode2 = {
+          type: "customBlock",
+          data: {
+            hName: componentName,
+            hProperties: {
+              payload: JSON.stringify(payload),
+              raw,
+              data: JSON.stringify(data)
+            }
+          },
+          children: []
+        };
+        parent.children[index] = customNode2;
+        return;
+      }
+      const contentMdast = processor.parse(raw);
+      const customNode = {
+        type: "customBlock",
+        data: {
+          hName: componentName,
+          hProperties: {
+            payload: JSON.stringify(payload),
+            raw
+          }
+        },
+        children: contentMdast.children
+      };
+      parent.children[index] = customNode;
+    });
+  };
+}
+
+// src/index.tsx
+function parseLocalMeta(content, processor, components) {
+  const metaPattern = /```@\|\s*\n([\s\S]*?)```\s*\n?/g;
+  let match;
+  let local = {};
+  let body = content;
+  while ((match = metaPattern.exec(content)) !== null) {
+    const parsed = parseYaml2(match[1]);
+    local = { ...local, ...parsed };
+  }
+  body = content.replace(metaPattern, "").trim();
+  const localMdPattern = /```@\/(\w+)\s*\n([\s\S]*?)```\s*\n?/g;
+  const localMdBlocks = {};
+  while ((match = localMdPattern.exec(body)) !== null) {
+    const name = match[1];
+    const content2 = match[2].trim();
+    if (localMdBlocks[name]) {
+      localMdBlocks[name] += "\n\n" + content2;
+    } else {
+      localMdBlocks[name] = content2;
+    }
+  }
+  body = body.replace(localMdPattern, "").trim();
+  for (const [name, mdContent] of Object.entries(localMdBlocks)) {
+    const mdast = processor.parse(mdContent);
+    const hastTree = processor.runSync(mdast);
+    local[name] = hastToSolidComponent(hastTree, components);
+  }
+  return { local, body };
+}
+function parseGlobalMeta(input, processor, components) {
+  const globalDataPattern = /```@@\|\s*\n([\s\S]*?)```/g;
+  let match;
+  let global = {};
+  while ((match = globalDataPattern.exec(input)) !== null) {
+    const parsed = parseYaml2(match[1]);
+    global = { ...global, ...parsed };
+  }
+  const globalMdPattern = /```@@\/(\w+)\s*\n([\s\S]*?)```/g;
+  const globalMdBlocks = {};
+  while ((match = globalMdPattern.exec(input)) !== null) {
+    const name = match[1];
+    const content = match[2].trim();
+    if (globalMdBlocks[name]) {
+      globalMdBlocks[name] += "\n\n" + content;
+    } else {
+      globalMdBlocks[name] = content;
+    }
+  }
+  for (const [name, mdContent] of Object.entries(globalMdBlocks)) {
+    const mdast = processor.parse(mdContent);
+    const hastTree = processor.runSync(mdast);
+    global[name] = hastToSolidComponent(hastTree, components);
+  }
+  return Object.keys(global).length > 0 ? global : null;
+}
+function isInsideCodeBlock(input, position) {
+  const beforeText = input.slice(0, position);
+  const fencePattern = /^```/gm;
+  let fenceCount = 0;
+  let match;
+  while ((match = fencePattern.exec(beforeText)) !== null) {
+    fenceCount++;
+  }
+  return fenceCount % 2 === 1;
+}
+var VALID_ID_PATTERN = /^[a-z0-9-]+$/;
+function validateStepId(id, lineNumber) {
+  if (!VALID_ID_PATTERN.test(id)) {
+    throw new Error(
+      `Invalid step ID "${id}" at line ${lineNumber}. Step IDs must only contain lowercase letters (a-z), numbers (0-9), and hyphens (-).`
+    );
+  }
+}
+function parse(input, components = {}) {
+  const stepPattern = /^\+\+\+(.+)$/gm;
+  const steps = {};
+  const componentNames = new Set(Object.keys(components));
+  const baseProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkMath);
+  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkCustomBlocks, {
+    components: componentNames,
+    processor: baseProcessor
+  }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeKatex);
+  const global = parseGlobalMeta(input, processor, components);
+  let match;
+  const matches = [];
+  while ((match = stepPattern.exec(input)) !== null) {
+    if (!isInsideCodeBlock(input, match.index)) {
+      const id = match[1].trim();
+      const lineNumber = input.slice(0, match.index).split("\n").length;
+      validateStepId(id, lineNumber);
+      matches.push({ id, index: match.index });
+    }
+  }
+  if (matches.length === 0) {
+    const { local, body: markdown } = parseLocalMeta(
+      input.trim(),
+      processor,
+      components
+    );
+    const mdast = processor.parse(markdown);
+    const hastTree = processor.runSync(mdast);
+    const Body = hastToSolidComponent(hastTree, components);
+    steps["default"] = {
+      id: "default",
+      local,
+      Body,
+      prev: null,
+      next: null,
+      current: 1
+    };
+    return {
+      first: "default",
+      steps,
+      count: 1,
+      global
+    };
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const current = matches[i];
+    const nextMatch = matches[i + 1];
+    const prevMatch = matches[i - 1];
+    const startIndex = current.index + `+++${current.id}`.length;
+    const endIndex = nextMatch ? nextMatch.index : input.length;
+    const rawContent = input.slice(startIndex, endIndex).trim();
+    const { local, body: markdown } = parseLocalMeta(
+      rawContent,
+      processor,
+      components
+    );
+    const mdast = processor.parse(markdown);
+    const hastTree = processor.runSync(mdast);
+    const Body = hastToSolidComponent(hastTree, components);
+    steps[current.id] = {
+      id: current.id,
+      local,
+      Body,
+      prev: prevMatch ? prevMatch.id : null,
+      next: nextMatch ? nextMatch.id : null,
+      current: i + 1
+    };
+  }
+  return {
+    first: matches.length > 0 ? matches[0].id : null,
+    steps,
+    count: matches.length,
+    global
+  };
+}
+export {
+  parse
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.tsx", "../src/hast-to-solid.tsx", "../src/remark-custom-blocks.ts"],
  "sourcesContent": ["import { Component, JSX } from \"solid-js\";\nimport { unified, type Processor } from \"unified\";\nimport remarkParse from \"remark-parse\";\nimport remarkGfm from \"remark-gfm\";\nimport remarkMath from \"remark-math\";\nimport remarkRehype from \"remark-rehype\";\nimport rehypeKatex from \"rehype-katex\";\nimport { parse as parseYaml } from \"yaml\";\nimport type { Root } from \"hast\";\nimport {\n  hastToSolidJsx,\n  hastToSolidComponent,\n  ComponentMap,\n} from \"./hast-to-solid\";\nimport { remarkCustomBlocks } from \"./remark-custom-blocks\";\n\nexport type {\n  ComponentMap,\n  CustomBlockProps,\n  StandardComponentProps,\n} from \"./hast-to-solid\";\n\nexport interface StepLocalBase {\n  [key: string]: unknown;\n}\n\nexport interface GlobalMetaBase {\n  [key: string]: unknown;\n}\n\nexport interface Step<TLocal = StepLocalBase> {\n  id: string;\n  local: TLocal;\n  /** Component function that renders the step body. Call it to get JSX: {step.Body()} */\n  Body: Component;\n  prev: string | null;\n  next: string | null;\n  current: number;\n}\n\nexport interface ParseResult<TGlobal = GlobalMetaBase, TLocal = StepLocalBase> {\n  first: string | null;\n  steps: Record<string, Step<TLocal>>;\n  count: number;\n  global: TGlobal | null;\n}\n\n\nfunction parseLocalMeta(\n  content: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>,\n  components: ComponentMap,\n): { local: StepLocalBase; body: string } {\n  // Match all local metadata blocks: ```@| ... ```\n  // Multiple blocks are merged, later values override earlier ones\n  const metaPattern = /```@\\|\\s*\\n([\\s\\S]*?)```\\s*\\n?/g;\n  let match: RegExpExecArray | null;\n  let local: StepLocalBase = {};\n  let body = content;\n\n  while ((match = metaPattern.exec(content)) !== null) {\n    const parsed = parseYaml(match[1]);\n    local = { ...local, ...parsed };\n  }\n\n  // Remove all metadata blocks from body\n  body = content.replace(metaPattern, \"\").trim();\n\n  // Match local md blocks: ```@/name ... ```\n  // These are markdown blocks that get rendered and stored in local[name]\n  const localMdPattern = /```@\\/(\\w+)\\s*\\n([\\s\\S]*?)```\\s*\\n?/g;\n  const localMdBlocks: Record<string, string> = {};\n\n  while ((match = localMdPattern.exec(body)) !== null) {\n    const name = match[1];\n    const content = match[2].trim();\n    // Concatenate if multiple blocks with same name\n    if (localMdBlocks[name]) {\n      localMdBlocks[name] += \"\\n\\n\" + content;\n    } else {\n      localMdBlocks[name] = content;\n    }\n  }\n\n  // Remove all local md blocks from body\n  body = body.replace(localMdPattern, \"\").trim();\n\n  // Convert all local md blocks to JSX\n  for (const [name, mdContent] of Object.entries(localMdBlocks)) {\n    const mdast = processor.parse(mdContent);\n    const hastTree = processor.runSync(mdast) as Root;\n    local[name] = hastToSolidComponent(hastTree, components);\n  }\n\n  return { local, body };\n}\n\nfunction parseGlobalMeta(\n  input: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>,\n  components: ComponentMap,\n): GlobalMetaBase | null {\n  // Match global data blocks: ```@@| ... ```\n  // Can appear anywhere in the document, may have multiple blocks\n  const globalDataPattern = /```@@\\|\\s*\\n([\\s\\S]*?)```/g;\n  let match: RegExpExecArray | null;\n  let global: GlobalMetaBase = {};\n\n  while ((match = globalDataPattern.exec(input)) !== null) {\n    const parsed = parseYaml(match[1]);\n    global = { ...global, ...parsed };\n  }\n\n  // Match global md blocks: ```@@/name ... ```\n  // These are markdown blocks that get rendered and stored in global[name]\n  const globalMdPattern = /```@@\\/(\\w+)\\s*\\n([\\s\\S]*?)```/g;\n  const globalMdBlocks: Record<string, string> = {};\n\n  while ((match = globalMdPattern.exec(input)) !== null) {\n    const name = match[1];\n    const content = match[2].trim();\n    // Concatenate if multiple blocks with same name\n    if (globalMdBlocks[name]) {\n      globalMdBlocks[name] += \"\\n\\n\" + content;\n    } else {\n      globalMdBlocks[name] = content;\n    }\n  }\n\n  // Convert all global md blocks to Components\n  for (const [name, mdContent] of Object.entries(globalMdBlocks)) {\n    const mdast = processor.parse(mdContent);\n    const hastTree = processor.runSync(mdast) as Root;\n    global[name] = hastToSolidComponent(hastTree, components);\n  }\n\n  return Object.keys(global).length > 0 ? global : null;\n}\n\nfunction isInsideCodeBlock(input: string, position: number): boolean {\n  // Find all code block fences before this position\n  const beforeText = input.slice(0, position);\n  const fencePattern = /^```/gm;\n  let fenceCount = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = fencePattern.exec(beforeText)) !== null) {\n    fenceCount++;\n  }\n\n  // If odd number of fences, we're inside a code block\n  return fenceCount % 2 === 1;\n}\n\nconst VALID_ID_PATTERN = /^[a-z0-9-]+$/;\n\nfunction validateStepId(id: string, lineNumber: number): void {\n  if (!VALID_ID_PATTERN.test(id)) {\n    throw new Error(\n      `Invalid step ID \"${id}\" at line ${lineNumber}. ` +\n        `Step IDs must only contain lowercase letters (a-z), numbers (0-9), and hyphens (-).`,\n    );\n  }\n}\n\nexport function parse<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(\n  input: string,\n  components: ComponentMap = {},\n): ParseResult<TGlobal, TLocal> {\n  // Capture everything after +++ until end of line\n  const stepPattern = /^\\+\\+\\+(.+)$/gm;\n  const steps: Record<string, Step<TLocal>> = {};\n  const componentNames = new Set(Object.keys(components));\n  const baseProcessor = unified()\n    .use(remarkParse)\n    .use(remarkGfm)\n    .use(remarkMath);\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkGfm)\n    .use(remarkMath)\n    .use(remarkCustomBlocks, {\n      components: componentNames,\n      processor: baseProcessor,\n    })\n    .use(remarkRehype, { allowDangerousHtml: true })\n    .use(rehypeKatex);\n  const global = parseGlobalMeta(input, processor, components);\n\n  let match: RegExpExecArray | null;\n  const matches: { id: string; index: number }[] = [];\n\n  while ((match = stepPattern.exec(input)) !== null) {\n    // Skip this match if it's inside a code block\n    if (!isInsideCodeBlock(input, match.index)) {\n      const id = match[1].trim();\n      // Calculate line number for error messages\n      const lineNumber = input.slice(0, match.index).split(\"\\n\").length;\n      validateStepId(id, lineNumber);\n      matches.push({ id, index: match.index });\n    }\n  }\n\n  // If no separators found, treat the entire input as a single \"default\" step\n  if (matches.length === 0) {\n    const { local, body: markdown } = parseLocalMeta(\n      input.trim(),\n      processor,\n      components,\n    );\n\n    const mdast = processor.parse(markdown);\n    const hastTree = processor.runSync(mdast) as Root;\n    const Body = hastToSolidComponent(hastTree, components);\n\n    steps[\"default\"] = {\n      id: \"default\",\n      local: local as TLocal,\n      Body,\n      prev: null,\n      next: null,\n      current: 1,\n    };\n\n    return {\n      first: \"default\",\n      steps,\n      count: 1,\n      global: global as TGlobal | null,\n    };\n  }\n\n  for (let i = 0; i < matches.length; i++) {\n    const current = matches[i];\n    const nextMatch = matches[i + 1];\n    const prevMatch = matches[i - 1];\n\n    const startIndex = current.index + `+++${current.id}`.length;\n    const endIndex = nextMatch ? nextMatch.index : input.length;\n\n    const rawContent = input.slice(startIndex, endIndex).trim();\n    const { local, body: markdown } = parseLocalMeta(\n      rawContent,\n      processor,\n      components,\n    );\n\n    const mdast = processor.parse(markdown);\n    const hastTree = processor.runSync(mdast) as Root;\n    const Body = hastToSolidComponent(hastTree, components);\n\n    steps[current.id] = {\n      id: current.id,\n      local: local as TLocal,\n      Body,\n      prev: prevMatch ? prevMatch.id : null,\n      next: nextMatch ? nextMatch.id : null,\n      current: i + 1,\n    };\n  }\n\n  return {\n    first: matches.length > 0 ? matches[0].id : null,\n    steps,\n    count: matches.length,\n    global: global as TGlobal | null,\n  };\n}\n", "import { JSX, Component, children as resolveChildren } from \"solid-js\";\nimport type { Root, Element, Text, RootContent } from \"hast\";\n\n/**\n * Props for custom block components (code blocks with name/sub/path syntax)\n */\nexport interface CustomBlockProps {\n  /** The path segments after the component name, e.g. ['substructure', 'subsub'] */\n  payload: string[];\n  /** The raw content of the code block as plain text */\n  raw: string;\n  /** Parsed YAML data when using componentName| syntax */\n  data?: Record<string, string | string[]>;\n  /** The markdown-rendered content as children */\n  children?: JSX.Element;\n}\n\n/**\n * Standard component props for regular HTML elements\n */\nexport interface StandardComponentProps {\n  children?: JSX.Element;\n  [key: string]: unknown;\n}\n\nexport type ComponentMap = {\n  [tagName: string]: Component<CustomBlockProps> | Component<StandardComponentProps>;\n};\n\nfunction convertProperties(\n  properties: Record<string, unknown> | undefined\n): Record<string, unknown> {\n  if (!properties) return {};\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(properties)) {\n    if (key === \"className\") {\n      result.class = value;\n    } else if (key === \"class\") {\n      result.class = Array.isArray(value) ? value.join(\" \") : value;\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\nfunction renderElement(\n  tagName: string,\n  props: Record<string, unknown>,\n  children: JSX.Element\n): JSX.Element {\n  switch (tagName) {\n    case \"p\":\n      return <p {...props}>{children}</p>;\n    case \"h1\":\n      return <h1 {...props}>{children}</h1>;\n    case \"h2\":\n      return <h2 {...props}>{children}</h2>;\n    case \"h3\":\n      return <h3 {...props}>{children}</h3>;\n    case \"h4\":\n      return <h4 {...props}>{children}</h4>;\n    case \"h5\":\n      return <h5 {...props}>{children}</h5>;\n    case \"h6\":\n      return <h6 {...props}>{children}</h6>;\n    case \"div\":\n      return <div {...props}>{children}</div>;\n    case \"span\":\n      return <span {...props}>{children}</span>;\n    case \"a\":\n      return <a {...props}>{children}</a>;\n    case \"strong\":\n      return <strong {...props}>{children}</strong>;\n    case \"b\":\n      return <b {...props}>{children}</b>;\n    case \"em\":\n      return <em {...props}>{children}</em>;\n    case \"i\":\n      return <i {...props}>{children}</i>;\n    case \"code\":\n      return <code {...props}>{children}</code>;\n    case \"pre\":\n      return <pre {...props}>{children}</pre>;\n    case \"blockquote\":\n      return <blockquote {...props}>{children}</blockquote>;\n    case \"ul\":\n      return <ul {...props}>{children}</ul>;\n    case \"ol\":\n      return <ol {...props}>{children}</ol>;\n    case \"li\":\n      return <li {...props}>{children}</li>;\n    case \"hr\":\n      return <hr {...props} />;\n    case \"br\":\n      return <br {...props} />;\n    case \"img\":\n      return <img {...props} />;\n    case \"table\":\n      return <table {...props}>{children}</table>;\n    case \"thead\":\n      return <thead {...props}>{children}</thead>;\n    case \"tbody\":\n      return <tbody {...props}>{children}</tbody>;\n    case \"tr\":\n      return <tr {...props}>{children}</tr>;\n    case \"th\":\n      return <th {...props}>{children}</th>;\n    case \"td\":\n      return <td {...props}>{children}</td>;\n    case \"del\":\n      return <del {...props}>{children}</del>;\n    case \"sup\":\n      return <sup {...props}>{children}</sup>;\n    case \"sub\":\n      return <sub {...props}>{children}</sub>;\n    // GFM elements\n    case \"input\":\n      return <input {...props} />;\n    case \"section\":\n      return <section {...props}>{children}</section>;\n    // KaTeX math elements\n    case \"math\":\n      return <math {...props}>{children}</math>;\n    case \"semantics\":\n      return <semantics {...props}>{children}</semantics>;\n    case \"mrow\":\n      return <mrow {...props}>{children}</mrow>;\n    case \"mi\":\n      return <mi {...props}>{children}</mi>;\n    case \"mo\":\n      return <mo {...props}>{children}</mo>;\n    case \"mn\":\n      return <mn {...props}>{children}</mn>;\n    case \"mfrac\":\n      return <mfrac {...props}>{children}</mfrac>;\n    case \"msup\":\n      return <msup {...props}>{children}</msup>;\n    case \"msub\":\n      return <msub {...props}>{children}</msub>;\n    case \"msubsup\":\n      return <msubsup {...props}>{children}</msubsup>;\n    case \"msqrt\":\n      return <msqrt {...props}>{children}</msqrt>;\n    case \"mroot\":\n      return <mroot {...props}>{children}</mroot>;\n    case \"munder\":\n      return <munder {...props}>{children}</munder>;\n    case \"mover\":\n      return <mover {...props}>{children}</mover>;\n    case \"munderover\":\n      return <munderover {...props}>{children}</munderover>;\n    case \"mtable\":\n      return <mtable {...props}>{children}</mtable>;\n    case \"mtr\":\n      return <mtr {...props}>{children}</mtr>;\n    case \"mtd\":\n      return <mtd {...props}>{children}</mtd>;\n    case \"mtext\":\n      return <mtext {...props}>{children}</mtext>;\n    case \"mspace\":\n      return <mspace {...props}>{children}</mspace>;\n    case \"annotation\":\n      return <annotation {...props}>{children}</annotation>;\n    case \"svg\":\n      return <svg {...props}>{children}</svg>;\n    case \"path\":\n      return <path {...props} />;\n    case \"line\":\n      return <line {...props} />;\n    case \"rect\":\n      return <rect {...props} />;\n    case \"circle\":\n      return <circle {...props} />;\n    case \"g\":\n      return <g {...props}>{children}</g>;\n    case \"defs\":\n      return <defs {...props}>{children}</defs>;\n    case \"clipPath\":\n      return <clipPath {...props}>{children}</clipPath>;\n    case \"use\":\n      return <use {...props} />;\n    default:\n      return <div {...props}>{children}</div>;\n  }\n}\n\nfunction renderNode(\n  node: RootContent,\n  components: ComponentMap\n): JSX.Element | string | null {\n  if (node.type === \"text\") {\n    return (node as Text).value;\n  }\n\n  if (node.type === \"element\") {\n    const element = node as Element;\n    const tagName = element.tagName;\n    const rawProps = convertProperties(element.properties);\n    const CustomComponent = components[tagName];\n\n    const childElements =\n      element.children.length > 0\n        ? element.children.map((child) => renderNode(child, components))\n        : null;\n\n    if (CustomComponent) {\n      // Check if this is a custom block component (has payload and raw props)\n      if (typeof rawProps.payload === \"string\" && typeof rawProps.raw === \"string\") {\n        // Deserialize payload from JSON string\n        const customBlockProps: CustomBlockProps = {\n          payload: JSON.parse(rawProps.payload as string),\n          raw: rawProps.raw as string,\n        };\n        // Add data if present (for componentName| syntax)\n        if (typeof rawProps.data === \"string\") {\n          customBlockProps.data = JSON.parse(rawProps.data as string);\n        }\n        const Comp = CustomComponent as Component<CustomBlockProps>;\n        return <Comp {...customBlockProps}>{childElements}</Comp>;\n      }\n      const Comp = CustomComponent as Component<StandardComponentProps>;\n      return <Comp {...rawProps}>{childElements}</Comp>;\n    }\n\n    return renderElement(tagName, rawProps, childElements as JSX.Element);\n  }\n\n  return null;\n}\n\nexport function hastToSolidJsx(\n  hastTree: Root,\n  components: ComponentMap = {}\n): JSX.Element {\n  const elements = hastTree.children.map((node) => renderNode(node, components));\n  return <>{elements}</>;\n}\n\n/**\n * Returns a component function that renders the HAST tree when called.\n * This defers JSX element creation until render time, which is important\n * for SSR hydration to work correctly.\n *\n * We serialize the HAST tree and components info so that the exact same\n * rendering logic runs on both server and client.\n */\nexport function hastToSolidComponent(\n  hastTree: Root,\n  components: ComponentMap = {}\n): () => JSX.Element {\n  // Store the tree data, not pre-rendered elements\n  const treeData = hastTree;\n  const componentMap = components;\n\n  return function HastBody() {\n    const elements = treeData.children.map((node) => renderNode(node, componentMap));\n    return <>{elements}</>;\n  };\n}\n", "import type { Root, Code, Parent, RootContent } from \"mdast\";\nimport type { Processor } from \"unified\";\nimport { visit } from \"unist-util-visit\";\nimport { parse as parseYaml } from \"yaml\";\n\n/**\n * Component that receives custom block props\n */\nexport interface CustomBlockComponentProps {\n  /** The path segments after the component name, e.g. ['substructure', 'subsub'] */\n  payload: string[];\n  /** The raw content of the code block as plain text */\n  raw: string;\n  /** Parsed YAML data when using componentName| syntax */\n  data?: Record<string, unknown>;\n  /** The markdown-rendered content as children */\n  children?: unknown;\n}\n\n/**\n * Set of component names that are available\n */\nexport type CustomBlockComponents = Set<string>;\n\nexport interface RemarkCustomBlocksOptions {\n  /** Set of component names that are available */\n  components: CustomBlockComponents;\n  /** The processor to use for parsing nested markdown */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>;\n}\n\n\n/**\n * A remark plugin that transforms code blocks with `name/path/segments` syntax\n * into custom block nodes that render with the specified component.\n *\n * Code blocks like:\n * ```componentName/sub/path\n * content here\n * ```\n *\n * Will be transformed to use the component if it exists in the components set,\n * otherwise they remain as regular code blocks.\n */\nexport function remarkCustomBlocks(options: RemarkCustomBlocksOptions) {\n  const { components, processor } = options;\n\n  return (tree: Root) => {\n    visit(tree, \"code\", (node: Code, index, parent: Parent | undefined) => {\n      if (!parent || index === undefined) return;\n\n      const lang = node.lang;\n      if (!lang) return;\n\n      // Check if this is a data block (lang ends with |)\n      const isDataBlock = lang.endsWith(\"|\");\n      const cleanLang = isDataBlock ? lang.slice(0, -1) : lang;\n\n      const segments = cleanLang.split(\"/\");\n      const componentName = segments[0];\n      const raw = node.value;\n\n      // If the component doesn't exist, leave it as a regular code block\n      if (!components.has(componentName)) return;\n\n      const payload = segments.slice(1);\n\n      // For data blocks, parse YAML instead of markdown\n      if (isDataBlock) {\n        const data = parseYaml(raw) as Record<string, unknown>;\n\n        const customNode = {\n          type: \"customBlock\",\n          data: {\n            hName: componentName,\n            hProperties: {\n              payload: JSON.stringify(payload),\n              raw,\n              data: JSON.stringify(data),\n            },\n          },\n          children: [],\n        };\n\n        parent.children[index] = customNode as unknown as RootContent;\n        return;\n      }\n\n      // Parse the content as markdown to get its AST\n      const contentMdast = processor.parse(raw) as Root;\n\n      // Create a custom element that will be converted to hast\n      // We use a custom node type that remark-rehype will handle\n      const customNode = {\n        type: \"customBlock\",\n        data: {\n          hName: componentName,\n          hProperties: {\n            payload: JSON.stringify(payload),\n            raw,\n          },\n        },\n        children: contentMdast.children,\n      };\n\n      // Replace the code node with our custom block\n      parent.children[index] = customNode as unknown as RootContent;\n    });\n  };\n}\n"],
  "mappings": "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",
  "names": ["parseYaml", "Comp", "customNode", "parseYaml", "content"]
}


package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "solid-mds",
+  "version": "0.3.2",
+  "description": "A SolidJS library for parsing and rendering MDS (Markdown Steps) format",
+  "license": "MIT",
+  "author": "Matthias Reis",
+  "keywords": [
+    "solid",
+    "solidjs",
+    "markdown",
+    "parser",
+    "slides",
+    "presentation",
+    "remark",
+    "rehype"
+  ],
+  "type": "module",
+  "main": "./dist/index.jsx",
+  "module": "./dist/index.jsx",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.jsx"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm run build",
+    "release": "bash ../../scripts/release.sh"
+  },
+  "dependencies": {
+    "yaml": "^2.7.0",
+    "rehype-katex": "^7.0.0",
+    "rehype-stringify": "^10.0.1",
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.1",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.0.0"
+  },
+  "devDependencies": {
+    "@solidjs/testing-library": "^0.8.0",
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.4",
+    "jsdom": "^26.0.0",
+    "tsup": "^8.3.5",
+    "tsup-preset-solid": "^2.2.0",
+    "typescript": "^5.7.3",
+    "vite-plugin-solid": "^2.10.0",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.9.0"
+  },
+  "typesVersions": {}
+}