defuss-markdown 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aron Homberg
+
+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,159 @@
+# defuss-markdown
+
+Incremental Markdown rendering for Defuss, using Incremark as the parser core.
+
+## Install
+
+```bash
+bun add defuss-markdown
+```
+
+## Usage
+
+```ts
+import { updateWithMarkdown } from "defuss-markdown";
+
+await updateWithMarkdown(containerOrRef, markdownStream);
+```
+
+`containerOrRef` can be:
+
+- a DOM `Element`
+- a Defuss ref exposing `render(jsx)`
+- a Defuss ref exposing `update(jsx)`
+- a ref-like object with `current: Element`
+
+`markdownStream` can be:
+
+- `string`
+- `Promise<string>`
+- `AsyncIterable<string>`
+- `AsyncIterator<string>`
+
+## What it does
+
+- streams chunks into Incremark
+- tracks incremental block updates
+- maps Markdown AST nodes to Defuss-compatible JSX/VNodes
+- renders keyed blocks so Defuss can morph incrementally
+
+## API
+
+```ts
+async function updateWithMarkdown(
+  target: Element | Ref,
+  input: string | Promise<string> | AsyncIterable<string> | AsyncIterator<string>,
+  options?: UpdateWithMarkdownOptions,
+): Promise<void>
+```
+
+### Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `parser` | `ParserLike` | Inject your own parser instance |
+| `createParser` | `() => ParserLike \| Promise<ParserLike>` | Inject a parser factory (sync or async) |
+| `parserOptions` | `Record<string, unknown>` | Passed to the default Incremark parser constructor/factory |
+| `render` | `(jsx, target) => void` | Custom render function (skips dynamic `defuss` import) |
+| `allowDangerousHtml` | `boolean` | Allow raw HTML nodes to use `dangerouslySetInnerHTML` (default: `false`) |
+| `blockWrapper` | `(block, rendered) => VNodeChild` | Wrap each rendered block with custom JSX |
+| `nodeRenderer` | `(node, context) => VNodeChild \| FALL_THROUGH` | Override or extend node rendering per-node |
+
+### `FALL_THROUGH`
+
+A sentinel symbol exported alongside `updateWithMarkdown`. Return it from a custom `nodeRenderer` to fall back to the built-in renderer for that node:
+
+```ts
+import { updateWithMarkdown, FALL_THROUGH } from "defuss-markdown";
+
+await updateWithMarkdown(target, markdown, {
+  nodeRenderer: (node) => {
+    if (node.type === "paragraph") {
+      // Custom paragraph rendering
+      return { type: "div", attributes: { class: "custom-p" }, children: [] };
+    }
+    return FALL_THROUGH; // default rendering for everything else
+  },
+});
+```
+
+### Supported Markdown AST Nodes
+
+The following node types are mapped to Defuss VNodes:
+
+| AST Node | HTML Output |
+|----------|-------------|
+| `paragraph` | `<p>` |
+| `heading` (depth 1-6) | `<h1>`-`<h6>` |
+| `text` | text node |
+| `strong` | `<strong>` |
+| `emphasis` | `<em>` |
+| `delete` | `<del>` |
+| `inlineCode` | `<code>` |
+| `code` | `<pre><code>` (with optional `language-*` class) |
+| `blockquote` | `<blockquote>` |
+| `list` | `<ul>` or `<ol>` (with `start` attr) |
+| `listItem` | `<li>` (with `<input type="checkbox">` when `checked` is boolean) |
+| `link` | `<a>` |
+| `image` | `<img>` |
+| `break` | `<br>` |
+| `thematicBreak` | `<hr>` |
+| `table` | `<table>` with `<thead>`/`<tbody>`, cell alignment via `style` |
+| `html` | `<pre>` (safe) or `<div dangerouslySetInnerHTML>` (when allowed) |
+| `math` | `<pre class="language-math">` |
+| `inlineMath` | `<code class="language-math">` |
+| `footnoteReference` | `<sup><a href="#fn-{id}">` |
+| `footnoteDefinition` | `<div id="fn-{id}" class="footnote-definition">` |
+| `yaml` | `<pre>` |
+| `definition` | _(omitted)_ |
+| `root` | children rendered directly |
+| unknown | `<div>` or `<span>` with `data-md-node` attr |
+
+### Parser Interface (`ParserLike`)
+
+Any object satisfying `ParserLike` can be injected. The library reads blocks through multiple fallback paths:
+
+1. `parser.getBlocks()` method
+2. `parser.getCompletedBlocks()` + `parser.pendingBlock` / `parser.pendingBlocks`
+3. `parser.blocks` property
+4. `parser.completedBlocks` + `parser.pendingBlocks` / `parser.pendingBlock`
+5. Incremental update objects returned from `append()` with `completed` / `pending` / `updated` / `removed` keys
+
+The parser must expose at least one of `append(chunk)` or `render(content)`.
+
+### Streaming Example
+
+```ts
+import { updateWithMarkdown } from "defuss-markdown";
+
+const stream = async function* () {
+  yield "# Hello\n\n";
+  yield "This is **streamed** markdown.\n";
+};
+
+await updateWithMarkdown(containerEl, stream(), {
+  render: (jsx, target) => myRender(jsx, target),
+});
+```
+
+## Notes
+
+By default the package tries to resolve either:
+
+- `createIncremarkParser(...)` from `@incremark/core`
+- `new IncremarkParser(...)` from `@incremark/core`
+
+and then uses Defuss `render(...)` for Element targets.
+
+For fully controlled environments, inject both the parser and render function through `options`.
+
+## Development
+
+```bash
+bun install
+bun test
+bun run test:coverage   # with v8 coverage report (text + html + lcov)
+bun run build
+```
+
+Coverage reports are generated in the `coverage/` directory.

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { VNodeChild, Ref } from 'defuss';
+
+type DefussPrimitive = string | number | boolean | null | undefined;
+interface MarkdownBlockLike {
+    id: string;
+    node: MarkdownAstNode;
+    status?: "pending" | "completed" | string;
+}
+interface MarkdownAstNode {
+    type: string;
+    children?: MarkdownAstNode[];
+    value?: string;
+    depth?: number;
+    ordered?: boolean;
+    start?: number;
+    spread?: boolean;
+    checked?: boolean | null;
+    lang?: string | null;
+    meta?: string | null;
+    url?: string;
+    alt?: string;
+    title?: string | null;
+    align?: Array<"left" | "right" | "center" | null>;
+    identifier?: string;
+    label?: string | null;
+    referenceType?: string;
+    name?: string;
+    attributes?: Array<{
+        type?: string;
+        name?: string;
+        value?: string;
+    }>;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface ParserLike {
+    append?: (chunk: string) => unknown;
+    finalize?: () => unknown;
+    render?: (content: string) => unknown;
+    reset?: () => void;
+    blocks?: MarkdownBlockLike[];
+    completedBlocks?: MarkdownBlockLike[];
+    pendingBlocks?: MarkdownBlockLike[];
+    pendingBlock?: MarkdownBlockLike | null;
+    getBlocks?: () => MarkdownBlockLike[];
+    getCompletedBlocks?: () => MarkdownBlockLike[];
+    [key: string]: unknown;
+}
+interface UpdateWithMarkdownOptions {
+    parser?: ParserLike;
+    createParser?: () => ParserLike | Promise<ParserLike>;
+    parserOptions?: Record<string, unknown>;
+    render?: (jsx: VNodeChild, target: Element) => unknown | Promise<unknown>;
+    allowDangerousHtml?: boolean;
+    blockWrapper?: (block: MarkdownBlockLike, rendered: VNodeChild) => VNodeChild;
+    nodeRenderer?: (node: MarkdownAstNode, context: RenderContext) => VNodeChild | typeof FALL_THROUGH;
+}
+declare const FALL_THROUGH: unique symbol;
+interface RenderContext {
+    allowDangerousHtml: boolean;
+    nodeRenderer?: UpdateWithMarkdownOptions["nodeRenderer"];
+    cellTag?: "td" | "th";
+}
+declare function updateWithMarkdown(target: Element | Ref, input: string | Promise<string> | AsyncIterable<string> | AsyncIterator<string>, options?: UpdateWithMarkdownOptions): Promise<void>;
+
+export { FALL_THROUGH, updateWithMarkdown };
+export type { DefussPrimitive, MarkdownAstNode, MarkdownBlockLike, ParserLike, UpdateWithMarkdownOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../src/index.ts"],"mappings":"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","names":[]}

package/dist/index.js

@@ -0,0 +1,477 @@
+const FALL_THROUGH = Symbol("defuss-markdown:fallback-renderer");
+const DEFAULT_PARSER_OPTIONS = Object.freeze({
+  gfm: true,
+  math: true,
+  htmlTree: true,
+  containers: true
+});
+async function updateWithMarkdown(target, input, options = {}) {
+  const parser = await getParser(options);
+  const state = createBlockState();
+  if (isAsyncIterable(input) || isAsyncIterator(input)) {
+    for await (const chunk of toAsyncIterable(input)) {
+      const update = appendChunk(parser, chunk);
+      hydrateStateFromParserOrUpdate(parser, update, state);
+      await renderIntoTarget(target, snapshotBlocks(state), options);
+    }
+    const finalizeUpdate2 = parser.finalize?.();
+    hydrateStateFromParserOrUpdate(parser, finalizeUpdate2, state);
+    await renderIntoTarget(target, snapshotBlocks(state), options);
+    return;
+  }
+  const content = await input;
+  appendChunk(parser, content);
+  const finalizeUpdate = parser.finalize?.();
+  hydrateStateFromParserOrUpdate(parser, finalizeUpdate, state);
+  await renderIntoTarget(target, snapshotBlocks(state), options);
+}
+async function getParser(options) {
+  if (options.parser) {
+    return options.parser;
+  }
+  if (options.createParser) {
+    return await options.createParser();
+  }
+  const incremark = await dynamicModuleImport("@incremark/core");
+  const parserOptions = { ...DEFAULT_PARSER_OPTIONS, ...options.parserOptions ?? {} };
+  if (typeof incremark?.createIncremarkParser === "function") {
+    return incremark.createIncremarkParser(parserOptions);
+  }
+  if (typeof incremark?.IncremarkParser === "function") {
+    return new incremark.IncremarkParser(parserOptions);
+  }
+  if (typeof incremark?.default === "function") {
+    try {
+      return new incremark.default(parserOptions);
+    } catch {
+      return incremark.default(parserOptions);
+    }
+  }
+  throw new Error(
+    "Could not construct an Incremark parser. Provide options.parser or options.createParser, or install @incremark/core with either createIncremarkParser() or IncremarkParser exported."
+  );
+}
+function appendChunk(parser, chunk) {
+  if (typeof parser.append === "function") {
+    return parser.append(chunk);
+  }
+  if (typeof parser.render === "function") {
+    return parser.render(chunk);
+  }
+  throw new Error("The provided parser does not expose append() or render().");
+}
+async function renderIntoTarget(target, blocks, options) {
+  const jsx = renderBlocks(blocks, options);
+  if (isRefLike(target)) {
+    const refRenderer = typeof target.render === "function" ? target.render : typeof target.update === "function" ? target.update : null;
+    if (refRenderer) {
+      await refRenderer.call(target, jsx);
+      return;
+    }
+    if (target.current instanceof Element) {
+      await renderIntoElement(target.current, jsx, options);
+      return;
+    }
+    throw new Error("Ref target has neither render()/update() nor a current Element.");
+  }
+  await renderIntoElement(target, jsx, options);
+}
+async function renderIntoElement(target, jsx, options) {
+  if (options.render) {
+    await options.render(jsx, target);
+    return;
+  }
+  const defuss = await dynamicModuleImport("defuss");
+  const render = defuss?.render ?? defuss?.default?.render ?? defuss?.default ?? null;
+  if (typeof render !== "function") {
+    throw new Error(
+      "Could not resolve defuss render(). Provide options.render, or install defuss exporting render()."
+    );
+  }
+  await render(jsx, target);
+}
+function renderBlocks(blocks, options) {
+  const context = {
+    allowDangerousHtml: Boolean(options.allowDangerousHtml),
+    nodeRenderer: options.nodeRenderer
+  };
+  return blocks.map((block) => {
+    const rendered = applyBlockKey(
+      block.id,
+      renderNode(block.node, context),
+      block
+    );
+    if (typeof options.blockWrapper === "function") {
+      return options.blockWrapper(block, rendered);
+    }
+    return rendered;
+  });
+}
+function renderNode(node, context) {
+  const custom = context.nodeRenderer?.(node, context);
+  if (custom !== void 0 && custom !== FALL_THROUGH) {
+    return custom;
+  }
+  switch (node.type) {
+    case "root":
+      return renderChildren(node.children, context);
+    case "paragraph":
+      return h("p", {}, renderChildren(node.children, context));
+    case "heading": {
+      const depth = clampHeadingDepth(node.depth);
+      return h(`h${depth}`, {}, renderChildren(node.children, context));
+    }
+    case "text":
+      return node.value ?? "";
+    case "strong":
+      return h("strong", {}, renderChildren(node.children, context));
+    case "emphasis":
+      return h("em", {}, renderChildren(node.children, context));
+    case "delete":
+      return h("del", {}, renderChildren(node.children, context));
+    case "inlineCode":
+      return h("code", {}, node.value ?? "");
+    case "code": {
+      const className = node.lang ? [`language-${String(node.lang)}`] : [];
+      const codeAttrs = className.length > 0 ? { class: className } : {};
+      return h("pre", {}, h("code", codeAttrs, node.value ?? ""));
+    }
+    case "blockquote":
+      return h("blockquote", {}, renderChildren(node.children, context));
+    case "list": {
+      const tag = node.ordered ? "ol" : "ul";
+      const attrs = {};
+      if (node.ordered && typeof node.start === "number" && node.start !== 1) {
+        attrs.start = node.start;
+      }
+      return h(tag, attrs, renderChildren(node.children, context));
+    }
+    case "listItem": {
+      const children = [...normalizeChildren(renderChildren(node.children, context))];
+      if (typeof node.checked === "boolean") {
+        children.unshift(
+          h("input", {
+            type: "checkbox",
+            checked: node.checked,
+            disabled: true
+          }),
+          " "
+        );
+      }
+      return h("li", {}, children);
+    }
+    case "link": {
+      const attrs = { href: node.url ?? "" };
+      if (node.title) {
+        attrs.title = node.title;
+      }
+      return h("a", attrs, renderChildren(node.children, context));
+    }
+    case "image": {
+      const attrs = {
+        src: node.url ?? "",
+        alt: node.alt ?? ""
+      };
+      if (node.title) {
+        attrs.title = node.title;
+      }
+      return h("img", attrs);
+    }
+    case "break":
+      return h("br", {});
+    case "thematicBreak":
+      return h("hr", {});
+    case "table":
+      return renderTable(node, context);
+    case "tableRow":
+      return h("tr", {}, renderTableRow(node, context.cellTag ?? "td", context));
+    case "tableCell":
+      return h(context.cellTag ?? "td", {}, renderChildren(node.children, context));
+    case "html": {
+      const html = String(node.value ?? "");
+      if (!context.allowDangerousHtml) {
+        return h("pre", {}, html);
+      }
+      return h("div", {
+        dangerouslySetInnerHTML: { __html: html }
+      });
+    }
+    case "math":
+      return h("pre", { class: ["language-math"] }, node.value ?? "");
+    case "inlineMath":
+      return h("code", { class: ["language-math"] }, node.value ?? "");
+    case "footnoteReference": {
+      const label = String(node.identifier ?? node.label ?? "fn");
+      return h(
+        "sup",
+        {},
+        h("a", { href: `#fn-${label}` }, `[${label}]`)
+      );
+    }
+    case "footnoteDefinition": {
+      const label = String(node.identifier ?? node.label ?? "fn");
+      return h(
+        "div",
+        { id: `fn-${label}`, class: ["footnote-definition"] },
+        renderChildren(node.children, context)
+      );
+    }
+    case "yaml":
+      return h("pre", {}, node.value ?? "");
+    case "definition":
+      return null;
+    default:
+      return renderUnknownNode(node, context);
+  }
+}
+function renderUnknownNode(node, context) {
+  if (Array.isArray(node.children) && node.children.length > 0) {
+    return h(
+      inferWrapperTag(node.type),
+      { "data-md-node": node.type },
+      renderChildren(node.children, context)
+    );
+  }
+  if (typeof node.value === "string") {
+    return h(inferWrapperTag(node.type), { "data-md-node": node.type }, node.value);
+  }
+  return h(inferWrapperTag(node.type), { "data-md-node": node.type });
+}
+function renderTable(node, context) {
+  const rows = Array.isArray(node.children) ? node.children : [];
+  if (rows.length === 0) {
+    return h("table", {});
+  }
+  const [headerRow, ...bodyRows] = rows;
+  const alignments = Array.isArray(node.align) ? node.align : [];
+  return h(
+    "table",
+    {},
+    h(
+      "thead",
+      {},
+      renderTableRow(headerRow, "th", { ...context, cellTag: "th" }, alignments)
+    ),
+    bodyRows.length > 0 ? h(
+      "tbody",
+      {},
+      bodyRows.map(
+        (row) => renderTableRow(row, "td", { ...context, cellTag: "td" }, alignments)
+      )
+    ) : null
+  );
+}
+function renderTableRow(row, cellTag, context, alignments = []) {
+  const cells = Array.isArray(row.children) ? row.children : [];
+  return h(
+    "tr",
+    {},
+    cells.map((cell, index) => {
+      const align = alignments[index];
+      const attrs = {};
+      if (align) {
+        attrs.style = { textAlign: align };
+      }
+      return h(
+        cellTag,
+        attrs,
+        renderChildren(cell.children, { ...context, cellTag })
+      );
+    })
+  );
+}
+function renderChildren(children, context) {
+  if (!Array.isArray(children) || children.length === 0) {
+    return [];
+  }
+  return children.map((child) => renderNode(child, context));
+}
+function applyBlockKey(blockId, rendered, block) {
+  if (isVNode(rendered)) {
+    rendered.attributes = {
+      ...rendered.attributes ?? {},
+      key: blockId,
+      "data-block-id": blockId,
+      "data-block-status": block.status ?? "pending"
+    };
+    return rendered;
+  }
+  return h(
+    "div",
+    {
+      key: blockId,
+      "data-block-id": blockId,
+      "data-block-status": block.status ?? "pending"
+    },
+    rendered
+  );
+}
+function createBlockState() {
+  return {
+    order: [],
+    map: /* @__PURE__ */ new Map()
+  };
+}
+function hydrateStateFromParserOrUpdate(parser, update, state) {
+  const directSnapshot = extractSnapshotBlocksFromUpdate(update);
+  if (directSnapshot) {
+    replaceState(state, directSnapshot);
+    return;
+  }
+  const parserSnapshot = extractBlocksFromParser(parser);
+  if (parserSnapshot) {
+    replaceState(state, parserSnapshot);
+    return;
+  }
+  applyIncrementalCollections(state, update);
+}
+function extractSnapshotBlocksFromUpdate(update) {
+  if (!update || typeof update !== "object") {
+    return null;
+  }
+  const value = update;
+  const direct = pickBlockArray(value.blocks);
+  return direct.length > 0 ? direct : null;
+}
+function extractBlocksFromParser(parser) {
+  const methodBlocks = pickBlockArray(parser.getBlocks?.());
+  if (methodBlocks.length > 0) {
+    return methodBlocks;
+  }
+  const methodMerged = mergeCompletedAndPending(
+    pickBlockArray(parser.getCompletedBlocks?.()),
+    pickBlockArray(parser.pendingBlocks ?? parser.pendingBlock)
+  );
+  if (methodMerged.length > 0) {
+    return methodMerged;
+  }
+  const propBlocks = pickBlockArray(parser.blocks);
+  if (propBlocks.length > 0) {
+    return propBlocks;
+  }
+  const propMerged = mergeCompletedAndPending(
+    pickBlockArray(parser.completedBlocks),
+    pickBlockArray(parser.pendingBlocks ?? parser.pendingBlock)
+  );
+  return propMerged.length > 0 ? propMerged : null;
+}
+function applyIncrementalCollections(state, update) {
+  if (!update || typeof update !== "object") {
+    return;
+  }
+  const value = update;
+  for (const key of ["completed", "updated", "pending"]) {
+    for (const block of pickBlockArray(value[key])) {
+      upsertBlock(state, block);
+    }
+  }
+  for (const block of pickBlockArray(value.removed)) {
+    removeBlock(state, block.id);
+  }
+}
+function replaceState(state, blocks) {
+  state.order = [];
+  state.map.clear();
+  for (const block of blocks) {
+    upsertBlock(state, block);
+  }
+}
+function upsertBlock(state, block) {
+  if (!state.map.has(block.id)) {
+    state.order.push(block.id);
+  }
+  state.map.set(block.id, block);
+}
+function removeBlock(state, id) {
+  state.map.delete(id);
+  state.order = state.order.filter((entry) => entry !== id);
+}
+function snapshotBlocks(state) {
+  return state.order.map((id) => state.map.get(id)).filter((block) => Boolean(block));
+}
+function mergeCompletedAndPending(completed, pending) {
+  return [...completed, ...pending];
+}
+function pickBlockArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter(isBlockLike);
+  }
+  if (isBlockLike(value)) {
+    return [value];
+  }
+  return [];
+}
+function isBlockLike(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.id === "string" && value.node && typeof value.node === "object"
+  );
+}
+function h(type, attributes = {}, ...children) {
+  return {
+    type,
+    attributes,
+    children: normalizeChildren(children)
+  };
+}
+function normalizeChildren(children) {
+  const normalized = [];
+  for (const child of children) {
+    if (Array.isArray(child)) {
+      normalized.push(...normalizeChildren(child));
+      continue;
+    }
+    if (child === null || child === void 0 || typeof child === "boolean") {
+      continue;
+    }
+    normalized.push(child);
+  }
+  return normalized;
+}
+function isVNode(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.type === "string"
+  );
+}
+function inferWrapperTag(type) {
+  if (type.includes("block") || type.includes("container") || type.includes("quote") || type.includes("definition")) {
+    return "div";
+  }
+  return "span";
+}
+function clampHeadingDepth(depth) {
+  if (typeof depth !== "number" || Number.isNaN(depth)) {
+    return 1;
+  }
+  if (depth < 1) return 1;
+  if (depth > 6) return 6;
+  return depth;
+}
+function isRefLike(value) {
+  return Boolean(value && typeof value === "object" && !(value instanceof Element));
+}
+function isAsyncIterable(value) {
+  return Boolean(value && typeof value[Symbol.asyncIterator] === "function");
+}
+function isAsyncIterator(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.next === "function"
+  );
+}
+async function* toAsyncIterable(input) {
+  if (isAsyncIterable(input)) {
+    yield* input;
+    return;
+  }
+  while (true) {
+    const result = await input.next();
+    if (result.done) {
+      return;
+    }
+    yield result.value;
+  }
+}
+async function dynamicModuleImport(specifier) {
+  return Function("specifier", "return import(specifier)")(specifier);
+}
+
+export { FALL_THROUGH, updateWithMarkdown };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "defuss-markdown",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Incremental Markdown -> Defuss JSX bridge built on Incremark core.",
+  "keywords": [
+    "markdown",
+    "defuss",
+    "incremark",
+    "streaming",
+    "jsx"
+  ],
+  "repository": {
+    "url": "git+https://github.com/kyr0/defuss.git",
+    "type": "git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Aron Homberg",
+    "email": "info@aron-homberg.de",
+    "url": "https://aron-homberg.de"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@incremark/core": "^1.0.2",
+    "defuss": "^3.4.5"
+  },
+  "scripts": {
+    "clean": "rm -rf dist coverage",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "build": "npm run test && pkgroll",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "pkgroll": "^2.27.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}