@stream-mdx/react 0.4.0 → 1.0.0

package/dist/renderer/node-views.mjs

@@ -1,1616 +0,0 @@
-"use client";
-
-// src/renderer/node-views.tsx
-import { stripCodeFence } from "@stream-mdx/core";
-import React5 from "react";
-
-// src/components/index.ts
-import { createTrustedHTML, sanitizeHTML } from "@stream-mdx/core";
-
-// src/renderer/use-deferred-render.ts
-import { useEffect, useState } from "react";
-function useDeferredRender(ref, options) {
-  const enabled = options?.enabled ?? true;
-  const [shouldRender, setShouldRender] = useState(!enabled);
-  useEffect(() => {
-    if (!enabled) {
-      setShouldRender(true);
-      return;
-    }
-    const target = ref.current;
-    if (!target) {
-      return;
-    }
-    let cancelled = false;
-    let idleId = null;
-    let timerId = null;
-    const scheduleRender = () => {
-      if (cancelled) return;
-      setShouldRender(true);
-    };
-    const runWithIdle = () => {
-      if (typeof globalThis.requestIdleCallback === "function") {
-        idleId = globalThis.requestIdleCallback(scheduleRender, { timeout: options?.idleTimeoutMs ?? 200 });
-      } else {
-        timerId = window.setTimeout(scheduleRender, options?.idleTimeoutMs ?? 200);
-      }
-    };
-    const observer = new IntersectionObserver(
-      (entries) => {
-        for (const entry of entries) {
-          if (entry.isIntersecting || entry.intersectionRatio > 0) {
-            observer.disconnect();
-            const debounceMs = options?.debounceMs ?? 80;
-            timerId = window.setTimeout(runWithIdle, debounceMs);
-            return;
-          }
-        }
-      },
-      { rootMargin: options?.rootMargin ?? "200px 0px" }
-    );
-    observer.observe(target);
-    return () => {
-      cancelled = true;
-      observer.disconnect();
-      if (idleId !== null && typeof globalThis.cancelIdleCallback === "function") {
-        globalThis.cancelIdleCallback(idleId);
-      }
-      if (timerId !== null) {
-        window.clearTimeout(timerId);
-      }
-    };
-  }, [enabled, options?.debounceMs, options?.idleTimeoutMs, options?.rootMargin, ref]);
-  return shouldRender;
-}
-
-// src/components/index.ts
-import { removeHeadingMarkers } from "@stream-mdx/core";
-import React2 from "react";
-
-// src/utils/inline-html.ts
-import React from "react";
-var BACKTICK_CONTENT = /^`([\s\S]+)`$/;
-var DEFAULT_INLINE_HTML_RENDERERS = {
-  kbd: (descriptor, ctx) => {
-    const trimmed = descriptor.rawInner.trim();
-    const match = BACKTICK_CONTENT.exec(trimmed);
-    if (match) {
-      const codeText = decodeHtmlEntities(match[1]);
-      const props = mapAttributesToProps(descriptor.attributes);
-      if (ctx.key !== void 0 && ctx.key !== null) {
-        props.key = ctx.key;
-      }
-      return React.createElement("kbd", props, React.createElement("code", { className: "inline-code" }, codeText));
-    }
-    return ctx.defaultRender();
-  }
-};
-function renderInlineHtmlSegment(raw, sanitized, options = {}) {
-  const descriptor = parseInlineHtmlDescriptor(raw, sanitized);
-  if (!descriptor) {
-    return null;
-  }
-  const className = options.className ?? "markdown-inline-html";
-  const isInlineTag = INLINE_ELEMENTS.has(descriptor.tagName);
-  const defaultRender = () => {
-    if (!descriptor.sanitized || descriptor.sanitized.length === 0) {
-      if (!descriptor.text) {
-        return null;
-      }
-      if (options.key !== void 0 && options.key !== null) {
-        return React.createElement(React.Fragment, { key: options.key }, descriptor.text);
-      }
-      return React.createElement(React.Fragment, {}, descriptor.text);
-    }
-    if (isInlineTag) {
-      const parsedElement = renderSanitizedHtmlTree(descriptor.sanitized, options.key);
-      if (parsedElement) {
-        return parsedElement;
-      }
-    }
-    const props = {
-      className,
-      dangerouslySetInnerHTML: { __html: descriptor.sanitized }
-    };
-    if (options.key !== void 0 && options.key !== null) {
-      props.key = options.key;
-    }
-    return React.createElement("span", props);
-  };
-  const allRenderers = options.renderers ? { ...DEFAULT_INLINE_HTML_RENDERERS, ...options.renderers } : DEFAULT_INLINE_HTML_RENDERERS;
-  const renderer = allRenderers[descriptor.tagName];
-  if (renderer) {
-    const rendered = renderer(descriptor, { key: options.key, defaultRender });
-    if (rendered) {
-      if (options.key !== void 0 && options.key !== null && React.isValidElement(rendered) && rendered.key === null) {
-        return React.cloneElement(rendered, { key: options.key });
-      }
-      return rendered;
-    }
-  }
-  return defaultRender();
-}
-function parseInlineHtmlDescriptor(raw, sanitized) {
-  const normalizedRaw = typeof raw === "string" ? raw.trim() : "";
-  const normalizedSanitized = typeof sanitized === "string" && sanitized.length > 0 ? sanitized.trim() : normalizedRaw;
-  if (!normalizedSanitized) {
-    return null;
-  }
-  const match = normalizedSanitized.match(/^<([A-Za-z][\w:-]*)(\s[^>]*)?>([\s\S]*)<\/\1>$/);
-  if (!match) {
-    return null;
-  }
-  const [, tagNameRaw, attrString = "", sanitizedInner = ""] = match;
-  const tagName = tagNameRaw.toLowerCase();
-  const attributes = parseAttributes(attrString);
-  let rawInner = "";
-  if (normalizedRaw) {
-    const rawMatch = normalizedRaw.match(/^<([A-Za-z][\w:-]*)(\s[^>]*)?>([\s\S]*)<\/\1>$/);
-    rawInner = rawMatch ? rawMatch[3] ?? "" : normalizedRaw;
-  }
-  const text = extractPlainText(rawInner || sanitizedInner);
-  return {
-    tagName,
-    attributes,
-    raw: normalizedRaw || normalizedSanitized,
-    sanitized: normalizedSanitized,
-    rawInner,
-    sanitizedInner,
-    text
-  };
-}
-function parseAttributes(input) {
-  const attrs = {};
-  if (!input) return attrs;
-  const attrPattern = /([A-Za-z_:][\w:.\-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
-  let match = attrPattern.exec(input);
-  while (match !== null) {
-    const name = match[1];
-    if (!name) continue;
-    const value = match[2] ?? match[3] ?? match[4] ?? "";
-    attrs[name] = value;
-    match = attrPattern.exec(input);
-  }
-  return attrs;
-}
-function mapAttributesToProps(attrs) {
-  const props = {};
-  for (const [key, value] of Object.entries(attrs)) {
-    if (key === "class") {
-      props.className = value;
-    } else if (key === "style") {
-      props.style = parseStyleAttribute(value);
-    } else if (key === "tabindex" || key === "tabIndex") {
-      const normalized = normalizeTabIndex(value);
-      if (normalized !== void 0) {
-        props.tabIndex = normalized;
-      }
-    } else {
-      props[key] = value;
-    }
-  }
-  return props;
-}
-function parseStyleAttribute(value) {
-  const style = {};
-  if (!value) return style;
-  const pairs = value.split(";");
-  for (const pair of pairs) {
-    if (!pair.trim()) continue;
-    const [property, rawVal] = pair.split(":");
-    if (!property || rawVal === void 0) continue;
-    const camelProp = property.trim().replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-    style[camelProp] = rawVal.trim();
-  }
-  return style;
-}
-function normalizeTabIndex(value) {
-  const numeric = Number(value);
-  return Number.isNaN(numeric) ? void 0 : numeric;
-}
-function decodeHtmlEntities(value) {
-  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
-}
-function extractPlainText(value) {
-  if (!value) return "";
-  const withoutTags = value.replace(/<\/?[^>]+>/g, "");
-  return decodeHtmlEntities(withoutTags);
-}
-function renderSanitizedHtmlTree(html, key) {
-  if (typeof DOMParser === "undefined") {
-    return null;
-  }
-  try {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(html, "text/html");
-    const body = doc.body;
-    const nodes = Array.from(body.childNodes);
-    if (nodes.length === 0) {
-      return null;
-    }
-    const baseKey = typeof key === "string" || typeof key === "number" ? String(key) : "inline-html";
-    const children = nodes.map((node, index) => convertDomNode(node, `${baseKey}-${index}`)).filter((child) => child !== null && child !== void 0);
-    if (children.length === 0) {
-      return null;
-    }
-    if (children.length === 1) {
-      const [child] = children;
-      if (React.isValidElement(child)) {
-        if (key !== void 0 && key !== null) {
-          return React.cloneElement(child, { key });
-        }
-        return child;
-      }
-      if (typeof child === "string" || typeof child === "number") {
-        if (key !== void 0 && key !== null) {
-          return React.createElement(React.Fragment, { key }, child);
-        }
-        return React.createElement(React.Fragment, {}, child);
-      }
-      return React.createElement(React.Fragment, { key }, child);
-    }
-    return React.createElement(React.Fragment, { key }, ...children);
-  } catch {
-    return null;
-  }
-}
-function convertDomNode(node, key) {
-  if (node.nodeType === Node.TEXT_NODE) {
-    return node.textContent ?? "";
-  }
-  if (node.nodeType !== Node.ELEMENT_NODE) {
-    return null;
-  }
-  const element = node;
-  const tagName = element.tagName.toLowerCase();
-  const attrs = getElementAttributes(element);
-  const props = mapAttributesToProps(attrs);
-  props.key = key;
-  const children = [];
-  element.childNodes.forEach((child, index) => {
-    const converted = convertDomNode(child, `${key}-${index}`);
-    if (converted !== null && converted !== void 0) {
-      children.push(converted);
-    }
-  });
-  if (children.length === 0) {
-    return React.createElement(tagName, props);
-  }
-  return React.createElement(tagName, props, ...children);
-}
-function getElementAttributes(element) {
-  const attrs = {};
-  for (const attr of Array.from(element.attributes)) {
-    attrs[attr.name] = attr.value;
-  }
-  return attrs;
-}
-var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
-  "a",
-  "abbr",
-  "b",
-  "bdi",
-  "bdo",
-  "br",
-  "cite",
-  "code",
-  "data",
-  "dfn",
-  "em",
-  "i",
-  "kbd",
-  "mark",
-  "q",
-  "rp",
-  "rt",
-  "ruby",
-  "s",
-  "samp",
-  "small",
-  "span",
-  "strong",
-  "sub",
-  "sup",
-  "time",
-  "u",
-  "var",
-  // MathML inline elements commonly emitted by KaTeX
-  "annotation",
-  "semantics",
-  "mtext",
-  "mn",
-  "mo",
-  "mi",
-  "mspace",
-  "mrow",
-  "msup",
-  "msub",
-  "msubsup",
-  "munder",
-  "mover",
-  "munderover",
-  "msqrt",
-  "mroot",
-  "mtable",
-  "mtr",
-  "mtd"
-]);
-
-// src/components/index.ts
-var MdxRuntimeBoundary = class extends React2.Component {
-  constructor() {
-    super(...arguments);
-    this.state = { hasError: false };
-  }
-  static getDerivedStateFromError() {
-    return { hasError: true };
-  }
-  componentDidCatch(error) {
-    this.props.onError(error);
-  }
-  componentDidUpdate(prevProps) {
-    if (prevProps.resetKey !== this.props.resetKey && this.state.hasError) {
-      this.setState({ hasError: false });
-    }
-  }
-  render() {
-    if (this.state.hasError) {
-      return null;
-    }
-    return this.props.children;
-  }
-};
-function renderInlineNodes(nodes, components) {
-  return nodes.map((node, index) => {
-    const key = `${node.kind}-${index}`;
-    switch (node.kind) {
-      case "text": {
-        const textComponent = components.text;
-        if (textComponent && textComponent !== defaultInlineComponents.text) {
-          return React2.createElement(textComponent, { key, text: node.text });
-        }
-        return React2.createElement(React2.Fragment, { key, children: node.text });
-      }
-      case "strong":
-        return React2.createElement(components.strong, {
-          key,
-          children: renderInlineNodes(node.children, components)
-        });
-      case "em":
-        return React2.createElement(components.em, {
-          key,
-          children: renderInlineNodes(node.children, components)
-        });
-      case "strike": {
-        const StrikeComponent = components.strike ?? ((props) => React2.createElement("del", {}, props.children));
-        return React2.createElement(StrikeComponent, {
-          key,
-          children: renderInlineNodes(node.children, components)
-        });
-      }
-      case "code":
-        return React2.createElement(components.code, { key, text: node.text });
-      case "link":
-        return React2.createElement(
-          components.link,
-          {
-            key,
-            href: node.href,
-            title: node.title,
-            children: renderInlineNodes(node.children, components)
-          }
-        );
-      case "image":
-        return React2.createElement(components.image, {
-          key,
-          src: node.src,
-          alt: node.alt,
-          title: node.title
-        });
-      case "br":
-        return React2.createElement(React2.Fragment, { key }, React2.createElement(components.br, {}));
-      default: {
-        const component = components[node.kind];
-        if (component) {
-          return React2.createElement(component, { key, ...node });
-        }
-        return null;
-      }
-    }
-  });
-}
-var defaultInlineComponents = {
-  text: ({ text }) => React2.createElement(React2.Fragment, {}, text),
-  strong: ({ children }) => React2.createElement("strong", {}, children),
-  em: ({ children }) => React2.createElement("em", {}, children),
-  strike: ({ children }) => React2.createElement("del", {}, children),
-  code: ({ text }) => React2.createElement(
-    "code",
-    {
-      className: "inline-code"
-    },
-    text
-  ),
-  link: ({ href, title, children }) => React2.createElement(
-    "a",
-    {
-      href,
-      title,
-      className: "markdown-link",
-      target: href?.startsWith("http") ? "_blank" : void 0,
-      rel: href?.startsWith("http") ? "noopener noreferrer" : void 0
-    },
-    children
-  ),
-  image: ({ src, alt, title }) => React2.createElement("img", {
-    src,
-    alt,
-    title,
-    className: "markdown-image"
-  }),
-  br: () => React2.createElement("br"),
-  // Custom extensible components
-  mention: ({ handle }) => React2.createElement(
-    "span",
-    {
-      className: "mention",
-      "data-handle": handle
-    },
-    `@${handle}`
-  ),
-  citation: ({ id }) => React2.createElement(
-    "span",
-    {
-      className: "citation",
-      "data-citation-id": id
-    },
-    `[${id}]`
-  ),
-  "math-inline": ({ tex }) => React2.createElement(
-    "span",
-    {
-      className: "math-inline",
-      "data-tex": tex
-    },
-    `$${tex}$`
-  ),
-  "math-display": ({ tex }) => React2.createElement(
-    "div",
-    {
-      className: "math-display markdown-math-display",
-      "data-tex": tex,
-      style: { overflowX: "auto" }
-    },
-    React2.createElement("span", { className: "math-display-content" }, `$$${tex}$$`)
-  ),
-  // Footnote inline reference (superscript anchor)
-  "footnote-ref": ({ label, number }) => {
-    const n = number ?? "?";
-    const href = number ? `#fn:${n}` : void 0;
-    const id = number ? `fnref:${n}` : void 0;
-    return React2.createElement("sup", { className: "footnote-ref" }, React2.createElement("a", { href, id, "data-label": label }, String(n)));
-  }
-};
-function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRenderers) {
-  const result = [];
-  let inlineBuffer = [];
-  let inlineGroupIndex = 0;
-  const pushRenderedNodes = (nodes, target, baseKey) => {
-    nodes.forEach((node, idx) => {
-      if (node === null || node === void 0) return;
-      const key = `${baseKey}-${idx}`;
-      if (React2.isValidElement(node)) {
-        target.push(node.key === key ? node : React2.cloneElement(node, { key }));
-      } else if (typeof node === "string" || typeof node === "number") {
-        target.push(React2.createElement(React2.Fragment, { key }, node));
-      } else {
-        target.push(React2.createElement(React2.Fragment, { key }, node));
-      }
-    });
-  };
-  const ensureArray = (value) => {
-    if (value === null || value === void 0) {
-      return [];
-    }
-    return Array.isArray(value) ? value : [value];
-  };
-  const flushInline = () => {
-    if (inlineBuffer.length === 0) {
-      return;
-    }
-    const key = `paragraph-inline-group-${inlineGroupIndex++}`;
-    result.push(
-      React2.createElement(
-        "p",
-        {
-          key,
-          className: "markdown-paragraph"
-        },
-        inlineBuffer
-      )
-    );
-    inlineBuffer = [];
-  };
-  segments.forEach((segment, index) => {
-    const key = `paragraph-segment-${index}`;
-    switch (segment.kind) {
-      case "text": {
-        const inlineNodes = Array.isArray(segment.inline) ? segment.inline : [];
-        if (inlineNodes.length === 0) {
-          if (segment.value) {
-            inlineBuffer.push(React2.createElement(React2.Fragment, { key }, segment.value));
-          }
-          break;
-        }
-        let chunk = [];
-        const pushChunk = (chunkNodes, chunkKey) => {
-          if (chunkNodes.length === 0) return;
-          const rendered = renderInlineNodes(chunkNodes, inlineComponents);
-          pushRenderedNodes(ensureArray(rendered), inlineBuffer, chunkKey);
-        };
-        inlineNodes.forEach((inlineNode, inlineIdx) => {
-          if (inlineNode.kind === "math-display") {
-            pushChunk(chunk, `${key}-chunk-${inlineIdx}`);
-            chunk = [];
-            flushInline();
-            const rendered = renderInlineNodes([inlineNode], inlineComponents);
-            pushRenderedNodes(ensureArray(rendered), result, `${key}-math-${inlineIdx}`);
-          } else {
-            chunk.push(inlineNode);
-          }
-        });
-        pushChunk(chunk, `${key}-chunk-tail`);
-        break;
-      }
-      case "mdx": {
-        const status = segment.status ?? "pending";
-        let element;
-        if (status === "compiled") {
-          element = React2.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
-        } else if (status === "error") {
-          const message = segment.value || "MDX error";
-          element = React2.createElement("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error" }, message);
-        } else {
-          element = React2.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": status }, segment.value);
-        }
-        inlineBuffer.push(React2.createElement(React2.Fragment, { key }, element));
-        break;
-      }
-      case "html": {
-        const html = segment.sanitized ?? segment.value;
-        const isBlockLevel = isBlockLevelHtml(html);
-        const element = renderInlineHtmlSegment(segment.value, segment.sanitized, {
-          key,
-          renderers: inlineHtmlRenderers
-        });
-        if (isBlockLevel) {
-          flushInline();
-          if (element) {
-            result.push(element);
-          } else if (html) {
-            result.push(
-              React2.createElement("div", {
-                key,
-                className: "markdown-inline-html-block",
-                dangerouslySetInnerHTML: { __html: html }
-              })
-            );
-          }
-        } else if (element) {
-          inlineBuffer.push(element);
-        }
-        break;
-      }
-      default:
-        break;
-    }
-  });
-  flushInline();
-  if (result.length === 0) {
-    return [
-      React2.createElement(
-        "p",
-        {
-          key: "paragraph-inline-group-0",
-          className: "markdown-paragraph"
-        },
-        inlineBuffer
-      )
-    ];
-  }
-  return result;
-}
-function isBlockLevelHtml(html) {
-  if (!html) return false;
-  const trimmed = html.trim();
-  if (!trimmed.startsWith("<")) {
-    return false;
-  }
-  const match = trimmed.match(/^<([A-Za-z][\w:-]*)\b/);
-  if (!match) {
-    return false;
-  }
-  const tag = match[1].toLowerCase();
-  return BLOCK_LEVEL_TAGS.has(tag);
-}
-var BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
-  "address",
-  "article",
-  "aside",
-  "blockquote",
-  "canvas",
-  "div",
-  "dl",
-  "fieldset",
-  "figcaption",
-  "figure",
-  "footer",
-  "form",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "header",
-  "hr",
-  "li",
-  "main",
-  "nav",
-  "ol",
-  "p",
-  "pre",
-  "section",
-  "table",
-  "ul",
-  "math"
-]);
-
-// src/renderer/hooks.ts
-import { useMemo, useSyncExternalStore } from "react";
-function useRendererNode(store, id) {
-  const selector = useMemo(() => {
-    return () => store.getNodeWithVersion(id);
-  }, [store, id]);
-  const snapshot = useSyncExternalStore(store.subscribe, selector, selector);
-  return snapshot.node;
-}
-function useRendererChildren(store, id) {
-  const selector = useMemo(() => {
-    return () => store.getChildrenWithVersion(id);
-  }, [store, id]);
-  const snapshot = useSyncExternalStore(store.subscribe, selector, selector);
-  return snapshot.children;
-}
-
-// src/renderer/code-highlight-context.tsx
-import React3 from "react";
-var CodeHighlightRequestContext = React3.createContext(null);
-function useCodeHighlightRequester() {
-  return React3.useContext(CodeHighlightRequestContext);
-}
-
-// src/renderer/deferred-render-context.tsx
-import React4 from "react";
-var DeferredRenderContext = React4.createContext(null);
-
-// src/renderer/store.ts
-import {
-  cloneBlock,
-  createBlockSnapshot,
-  extractCodeWrapperAttributes,
-  getDefaultCodeWrapperAttributes,
-  sanitizeCodeHTML,
-  sanitizeHTML as sanitizeHTML2,
-  PATCH_ROOT_ID
-} from "@stream-mdx/core";
-var NODE_SNAPSHOT_CACHE_LIMIT = 5e4;
-var CHILDREN_SNAPSHOT_CACHE_LIMIT = 5e4;
-var NODE_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(NODE_SNAPSHOT_CACHE_LIMIT * 0.1));
-var CHILDREN_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(CHILDREN_SNAPSHOT_CACHE_LIMIT * 0.1));
-var EMPTY_CHILDREN = Object.freeze([]);
-var EMPTY_NODE_SNAPSHOT = Object.freeze({ version: -1, node: void 0 });
-var EMPTY_CHILDREN_SNAPSHOT = Object.freeze({
-  version: -1,
-  children: EMPTY_CHILDREN
-});
-function isListPatchDebugEnabled() {
-  if (typeof globalThis !== "undefined") {
-    const flag = globalThis.__STREAMING_LIST_DEBUG__;
-    if (flag === true) return true;
-  }
-  if (typeof process !== "undefined" && process.env.NEXT_PUBLIC_STREAMING_LIST_DEBUG === "true") {
-    return true;
-  }
-  return false;
-}
-var CODE_BLOCK_DEBUG_ENABLED = (() => {
-  try {
-    if (typeof process !== "undefined" && process.env && process.env.NEXT_PUBLIC_STREAMING_DEBUG_CODELINES === "1") {
-      return true;
-    }
-    if (typeof globalThis !== "undefined") {
-      const debug = globalThis?.__STREAMING_DEBUG__;
-      if (debug?.codeLines) {
-        return true;
-      }
-    }
-  } catch {
-  }
-  return false;
-})() || false;
-var CODE_BLOCK_VALIDATION_ENABLED = typeof process !== "undefined" && process.env ? process.env.NODE_ENV !== "production" : true;
-var getPerfNow = (() => {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return () => performance.now();
-  }
-  return () => Date.now();
-})();
-
-// src/renderer/virtualized-code.tsx
-import { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
-var DEFAULT_VIRTUALIZED_CODE_CONFIG = {
-  enabled: true,
-  windowSize: 100,
-  // Render 100 lines at a time
-  bufferSize: 50,
-  // +50 lines buffer above/below
-  virtualizeThreshold: 200
-  // Only virtualize if 200+ lines
-};
-function calculateCodeWindow(lines, scrollTop, containerHeight, lineHeight, config) {
-  const totalLines = lines.length;
-  if (!config.enabled || totalLines < config.virtualizeThreshold) {
-    return {
-      startIndex: 0,
-      endIndex: totalLines,
-      visibleStart: 0,
-      visibleEnd: totalLines,
-      visibleLines: lines,
-      totalLines,
-      mountedLines: totalLines
-    };
-  }
-  const firstVisibleLine = Math.floor(scrollTop / lineHeight);
-  const lastVisibleLine = Math.ceil((scrollTop + containerHeight) / lineHeight);
-  const visibleStart = Math.max(0, firstVisibleLine);
-  const visibleEnd = Math.min(totalLines, Math.max(visibleStart, lastVisibleLine));
-  const startIndex = Math.max(0, visibleStart - config.bufferSize);
-  const endIndex = Math.min(totalLines, visibleEnd + config.bufferSize);
-  return {
-    startIndex,
-    endIndex,
-    visibleStart,
-    visibleEnd,
-    visibleLines: lines.slice(startIndex, endIndex),
-    totalLines,
-    mountedLines: endIndex - startIndex
-  };
-}
-function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
-  const containerRef = useRef(null);
-  const [scrollTop, setScrollTop] = useState2(0);
-  const [containerHeight, setContainerHeight] = useState2(0);
-  const lineHeightRef = useRef(20);
-  useEffect2(() => {
-    if (!containerRef.current || lines.length === 0) return;
-    const timeoutId = setTimeout(() => {
-      if (!containerRef.current) return;
-      const firstLine = containerRef.current.querySelector(".line");
-      if (firstLine) {
-        const measuredHeight = firstLine.offsetHeight || 20;
-        if (measuredHeight !== lineHeightRef.current) {
-          lineHeightRef.current = measuredHeight;
-        }
-      }
-    }, 0);
-    return () => clearTimeout(timeoutId);
-  }, [lines.length]);
-  const handleScroll = useCallback((e) => {
-    const target = e.currentTarget;
-    setScrollTop(target.scrollTop);
-    setContainerHeight(target.clientHeight);
-  }, []);
-  useEffect2(() => {
-    if (!containerRef.current) return;
-    const resizeObserver = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        setContainerHeight(entry.contentRect.height);
-      }
-    });
-    resizeObserver.observe(containerRef.current);
-    return () => resizeObserver.disconnect();
-  }, []);
-  const window2 = useMemo2(() => {
-    return calculateCodeWindow(lines, scrollTop, containerHeight, lineHeightRef.current, config);
-  }, [lines, scrollTop, containerHeight, config]);
-  const scrollToLine = useCallback((lineIndex) => {
-    if (!containerRef.current) return;
-    const targetScrollTop = lineIndex * lineHeightRef.current;
-    containerRef.current.scrollTop = targetScrollTop;
-    setScrollTop(targetScrollTop);
-  }, []);
-  return {
-    containerRef,
-    window: window2,
-    handleScroll,
-    scrollToLine,
-    lineHeight: lineHeightRef.current,
-    config
-  };
-}
-
-// src/renderer/node-views.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var BlockNodeRenderer = ({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  const block = node?.block;
-  if (!node || !block) return null;
-  switch (block.type) {
-    case "paragraph":
-      return /* @__PURE__ */ jsx(ParagraphBlockView, { store, blockId: block.id, registry });
-    case "blockquote":
-      return /* @__PURE__ */ jsx(BlockquoteBlockView, { store, blockId: block.id, registry });
-    case "list":
-      return /* @__PURE__ */ jsx(ListBlockView, { store, blockId: block.id, registry, depth: 0 });
-    case "table":
-      return /* @__PURE__ */ jsx(TableBlockView, { store, blockId: block.id, registry });
-    case "code":
-      return /* @__PURE__ */ jsx(CodeBlockView, { store, blockId: block.id, registry });
-    case "html":
-      return /* @__PURE__ */ jsx(HtmlBlockView, { store, blockId: block.id, registry });
-    case "mdx":
-      return /* @__PURE__ */ jsx(MdxBlockView, { store, blockId: block.id, registry });
-    default:
-      return registry.renderBlock(block);
-  }
-};
-var ParagraphBlockView = React5.memo(({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  const block = node?.block;
-  const childIds = useRendererChildren(store, blockId);
-  if (!node || !block) {
-    return null;
-  }
-  const inlineComponents = registry.getInlineComponents();
-  if (!block.isFinalized) {
-    const raw = typeof block.payload.raw === "string" ? block.payload.raw : "";
-    const meta = block.payload.meta ?? {};
-    const segments2 = Array.isArray(meta.mixedSegments) ? meta.mixedSegments : [];
-    if (segments2.length > 0) {
-      const allowMixedStreaming = Boolean(meta.allowMixedStreaming);
-      if (!allowMixedStreaming) {
-        return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: raw });
-      }
-      const structured = renderParagraphMixedSegments(segments2, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
-      if (structured.length === 1) {
-        const [single] = structured;
-        return React5.isValidElement(single) ? single : single;
-      }
-      return structured;
-    }
-    if (meta.inlineStatus === "complete" || meta.inlineStatus === "anticipated") {
-      const inlineNodes2 = block.payload.inline ?? [];
-      const containsDisplayMath2 = inlineNodes2.some((node2) => node2.kind === "math-display");
-      if (containsDisplayMath2) {
-        const derivedSegments = [
-          {
-            kind: "text",
-            value: raw,
-            inline: inlineNodes2
-          }
-        ];
-        const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
-        if (structured.length === 1) {
-          const [single] = structured;
-          return React5.isValidElement(single) ? single : single;
-        }
-        return structured;
-      }
-      return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: renderInlineNodes(inlineNodes2, inlineComponents) });
-    }
-    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: raw });
-  }
-  const propsBlock = node.props?.block;
-  const inlineStatus = propsBlock?.payload?.meta?.inlineStatus ?? block.payload.meta?.inlineStatus ?? node.props?.inlineStatus;
-  if (inlineStatus && inlineStatus !== "complete") {
-    const raw = typeof block.payload.raw === "string" ? block.payload.raw : "";
-    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: raw });
-  }
-  const segments = Array.isArray(block.payload.meta?.mixedSegments) ? block.payload.meta.mixedSegments : void 0;
-  if (segments && segments.length > 0) {
-    const structured = renderParagraphMixedSegments(segments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
-    if (structured.length === 1) {
-      const [single] = structured;
-      return React5.isValidElement(single) ? single : single;
-    }
-    return structured;
-  }
-  const inlineNodes = block.payload.inline ?? [];
-  const containsDisplayMath = inlineNodes.some((node2) => node2.kind === "math-display");
-  if (containsDisplayMath) {
-    const derivedSegments = [
-      {
-        kind: "text",
-        value: typeof block.payload.raw === "string" ? block.payload.raw : "",
-        inline: inlineNodes
-      }
-    ];
-    const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
-    if (structured.length === 1) {
-      const [single] = structured;
-      return React5.isValidElement(single) ? single : single;
-    }
-    return structured;
-  }
-  const ParagraphComponent = registry.getBlockComponent("paragraph");
-  const baseElement = React5.createElement(ParagraphComponent, {
-    inlines: block.payload.inline ?? [],
-    raw: block.payload.raw,
-    meta: block.payload.meta
-  });
-  if (childIds.length > 0) {
-    const renderedChildren = childIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
-    if (React5.isValidElement(baseElement)) {
-      const { children: _ignored, className = "markdown-paragraph", inlines: _inlines, raw: _raw, meta: _meta, ...rest } = baseElement.props ?? {};
-      return React5.createElement("p", { ...rest, className }, renderedChildren);
-    }
-    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: renderedChildren });
-  }
-  if (React5.isValidElement(baseElement)) {
-    return baseElement;
-  }
-  return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: renderInlineNodes(block.payload.inline ?? [], inlineComponents) });
-});
-ParagraphBlockView.displayName = "ParagraphBlockView";
-var BlockquoteBlockView = React5.memo(({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  const block = node?.block;
-  const childIds = useRendererChildren(store, blockId);
-  if (!node || !block) {
-    return null;
-  }
-  const meta = block.payload.meta ?? {};
-  const mixedSegments = Array.isArray(meta.mixedSegments) ? meta.mixedSegments : [];
-  const normalizedText = typeof meta.normalizedText === "string" && meta.normalizedText.length > 0 ? meta.normalizedText : typeof block.payload.raw === "string" ? block.payload.raw : "";
-  const inlineComponents = registry.getInlineComponents();
-  const renderTextWithBreaks = (text, keyPrefix) => {
-    const lines = text.split("\n");
-    const lastIndex = lines.length - 1;
-    let offset = 0;
-    return lines.map((line, idx) => {
-      const key = `${keyPrefix}${offset}`;
-      offset += line.length + 1;
-      return /* @__PURE__ */ jsxs("span", { className: "markdown-blockquote-line", children: [
-        line,
-        idx < lastIndex ? /* @__PURE__ */ jsx("br", {}) : null
-      ] }, key);
-    });
-  };
-  const renderInlineContent = (inline, keyPrefix) => {
-    if (inline && inline.length > 0) {
-      return renderInlineNodes(inline, inlineComponents);
-    }
-    return null;
-  };
-  const renderMixedSegments = () => {
-    if (!mixedSegments.length) {
-      return [];
-    }
-    const elements = [];
-    mixedSegments.forEach((segment, segmentIndex) => {
-      switch (segment.kind) {
-        case "html": {
-          const htmlNode = renderInlineHtmlSegment(segment.value, segment.sanitized ?? segment.value, {
-            key: `blockquote-html-${block.id}-${segmentIndex}`,
-            renderers: DEFAULT_INLINE_HTML_RENDERERS
-          });
-          if (htmlNode) {
-            elements.push(htmlNode);
-          } else {
-            elements.push(
-              React5.createElement("span", {
-                key: `blockquote-html-${block.id}-${segmentIndex}`,
-                className: "markdown-inline-html",
-                /* biome-ignore lint/security/noDangerouslySetInnerHtml: segment content is sanitized by the worker before streaming */
-                dangerouslySetInnerHTML: { __html: segment.sanitized ?? segment.value }
-              })
-            );
-          }
-          break;
-        }
-        case "mdx":
-          elements.push(
-            /* @__PURE__ */ jsx("span", { "data-mdx-status": segment.status ?? "pending", children: segment.value }, `blockquote-mdx-${block.id}-${segmentIndex}`)
-          );
-          break;
-        default: {
-          const inline = renderInlineContent(segment.inline, `blockquote-text-inline-${block.id}-${segmentIndex}-`);
-          if (inline) {
-            elements.push(/* @__PURE__ */ jsx(React5.Fragment, { children: inline }, `blockquote-inline-${block.id}-${segmentIndex}`));
-          } else {
-            elements.push(
-              /* @__PURE__ */ jsx(React5.Fragment, { children: renderTextWithBreaks(segment.value, `blockquote-text-${block.id}-${segmentIndex}-`) }, `blockquote-text-${block.id}-${segmentIndex}`)
-            );
-          }
-          break;
-        }
-      }
-    });
-    return elements;
-  };
-  const mixedSegmentElements = renderMixedSegments();
-  const fallbackElements = normalizedText ? renderTextWithBreaks(normalizedText, `blockquote-fallback-${block.id}-`) : null;
-  const inlineNodes = block.payload.inline ?? [];
-  const inlineElements = inlineNodes.length > 0 ? renderInlineNodes(inlineNodes, inlineComponents) : null;
-  if (!block.isFinalized) {
-    const streamingContent = mixedSegmentElements.length ? mixedSegmentElements : inlineElements ? inlineElements : fallbackElements;
-    const shouldShowStreaming = !block.isFinalized && (!streamingContent || Array.isArray(streamingContent) && streamingContent.length === 0);
-    const className = shouldShowStreaming ? "markdown-blockquote streaming-partial" : "markdown-blockquote";
-    return /* @__PURE__ */ jsx("blockquote", { className, children: streamingContent });
-  }
-  const childContent = childIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
-  const renderedContent = (() => {
-    if (mixedSegmentElements.length > 0) {
-      return mixedSegmentElements;
-    }
-    if (childIds.length > 0) {
-      const resolved = childContent.filter((child) => child !== null);
-      if (resolved.length > 0) {
-        return resolved;
-      }
-    }
-    if (inlineElements) {
-      return inlineElements;
-    }
-    if (fallbackElements && fallbackElements.length > 0) {
-      return fallbackElements;
-    }
-    return null;
-  })();
-  const BlockquoteComponent = registry.getBlockComponent("blockquote");
-  const baseElement = React5.createElement(
-    BlockquoteComponent,
-    {
-      inlines: block.payload.inline ?? [],
-      renderedContent
-    },
-    renderedContent
-  );
-  if (React5.isValidElement(baseElement)) {
-    return baseElement;
-  }
-  return /* @__PURE__ */ jsx("blockquote", { className: "markdown-blockquote", children: renderedContent });
-});
-BlockquoteBlockView.displayName = "BlockquoteBlockView";
-var MixedSegmentView = React5.memo(({ store, nodeId, inlineComponents }) => {
-  const node = useRendererNode(store, nodeId);
-  if (!node) return null;
-  switch (node.type) {
-    case "paragraph-text":
-    case "blockquote-text":
-    case "list-item-text": {
-      const inline = node.props?.inline ?? [];
-      if (inline.length > 0) {
-        return renderInlineNodes(inline, inlineComponents);
-      }
-      const text = typeof node.props?.text === "string" ? node.props?.text : "";
-      if (!text) return null;
-      return text;
-    }
-    case "paragraph-html":
-    case "blockquote-html":
-    case "list-item-html": {
-      const raw = typeof node.props?.raw === "string" ? node.props.raw : void 0;
-      const html = typeof node.props?.html === "string" ? node.props?.html : "";
-      const rendered = renderInlineHtmlSegment(raw, html, {
-        key: node.id,
-        renderers: DEFAULT_INLINE_HTML_RENDERERS
-      });
-      if (rendered) {
-        return rendered;
-      }
-      if (!html) return null;
-      return React5.createElement("span", {
-        className: "markdown-inline-html",
-        /* biome-ignore lint/security/noDangerouslySetInnerHtml: html is sanitized upstream before reaching the renderer */
-        dangerouslySetInnerHTML: { __html: html }
-      });
-    }
-    case "paragraph-mdx":
-    case "blockquote-mdx":
-    case "list-item-mdx": {
-      const status = node.props?.status ?? "pending";
-      const raw = typeof node.props?.raw === "string" ? node.props?.raw : "";
-      if (status === "compiled") {
-        return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
-      }
-      if (status === "error") {
-        const message = raw || "MDX error";
-        return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error", children: message });
-      }
-      return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline", "data-mdx-status": status, children: status === "compiled" ? "" : raw });
-    }
-    default:
-      return null;
-  }
-});
-MixedSegmentView.displayName = "MixedSegmentView";
-var HtmlBlockView = React5.memo(({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  if (!node || !node.block) return null;
-  return registry.renderBlock(node.block);
-});
-HtmlBlockView.displayName = "HtmlBlockView";
-var MdxBlockView = React5.memo(({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  if (!node || !node.block) return null;
-  return registry.renderBlock(node.block);
-});
-MdxBlockView.displayName = "MdxBlockView";
-var ListBlockView = React5.memo(
-  ({ store, blockId, registry, depth = 0 }) => {
-    const node = useRendererNode(store, blockId);
-    const block = node?.block;
-    const childIds = useRendererChildren(store, blockId);
-    const inlineComponents = registry.getInlineComponents();
-    const ordered = Boolean(node?.props?.ordered ?? block?.payload.meta?.ordered);
-    const Tag = ordered ? "ol" : "ul";
-    const listDebugEnabled = isListPatchDebugEnabled();
-    const listItemIds = React5.useMemo(() => {
-      const ids = [];
-      for (const childId of childIds) {
-        const childNode = store.getNode(childId);
-        if (childNode?.type === "list-item") {
-          ids.push(childId);
-        }
-      }
-      return ids;
-    }, [childIds, store]);
-    React5.useEffect(() => {
-      if (!listDebugEnabled) return;
-      const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
-      console.info("[stream-mdx:list-render]", {
-        listId: blockId,
-        depth,
-        ordered,
-        childIds,
-        childTypes,
-        listItemIds,
-        listItems: listItemIds.length,
-        totalChildren: childIds.length,
-        isFinalized: block?.isFinalized ?? false
-      });
-    }, [listDebugEnabled, blockId, depth, ordered, childIds, listItemIds, store, block?.isFinalized]);
-    const listStyle = React5.useMemo(() => {
-      if (!ordered || listItemIds.length === 0) return void 0;
-      let maxDigits = 1;
-      listItemIds.forEach((childId, index) => {
-        const childNode = store.getNode(childId);
-        const raw = typeof childNode?.block?.payload?.raw === "string" ? childNode.block.payload.raw : void 0;
-        const markerMatch = raw ? raw.match(/^([^\s]+)\s+/) : null;
-        const marker = markerMatch?.[1]?.trim();
-        const text = marker ?? `${index + 1}.`;
-        const digitMatch = text.match(/\d/g);
-        const digits = digitMatch ? digitMatch.length : text.length;
-        if (digits > maxDigits) maxDigits = digits;
-      });
-      const baseIndent = depth === 0 ? "2.5rem" : depth === 1 ? "2rem" : "1.5rem";
-      return {
-        ["--list-indent"]: `calc(${baseIndent} + ${maxDigits}ch)`
-      };
-    }, [ordered, listItemIds, store, depth]);
-    if (listItemIds.length === 0) return null;
-    return /* @__PURE__ */ jsx(
-      Tag,
-      {
-        className: `markdown-list ${ordered ? "ordered" : "unordered"}`,
-        "data-list-depth": depth,
-        "data-list-id": listDebugEnabled ? blockId : void 0,
-        style: listStyle,
-        children: listItemIds.map((childId, index) => /* @__PURE__ */ jsx(
-          ListItemView,
-          {
-            store,
-            nodeId: childId,
-            inlineComponents,
-            registry,
-            ordered,
-            index,
-            depth
-          },
-          childId
-        ))
-      }
-    );
-  }
-);
-ListBlockView.displayName = "ListBlockView";
-var ListItemView = React5.memo(({ store, nodeId, inlineComponents, registry, ordered, index, depth }) => {
-  const node = useRendererNode(store, nodeId);
-  const childIds = useRendererChildren(store, nodeId);
-  const inline = node?.props?.inline ?? [];
-  const isTask = Boolean(node?.props?.task);
-  const isChecked = Boolean(node?.props?.checked);
-  const block = node?.block;
-  const raw = typeof block?.payload?.raw === "string" ? block.payload.raw : void 0;
-  const markerMatch = raw ? raw.match(/^([^\s]+)\s+/) : null;
-  const marker = markerMatch?.[1]?.trim();
-  const inferredIndex = typeof node?.props?.index === "number" ? Number(node?.props?.index) : index;
-  const isOrdered = Boolean(node?.props?.ordered ?? ordered);
-  const counterText = !isTask ? isOrdered ? marker ? marker : `${inferredIndex + 1}.` : "\u2022" : void 0;
-  const listDebugEnabled = isListPatchDebugEnabled();
-  const inlineLength = inline.length;
-  const [segmentChildIds, contentChildIds] = React5.useMemo(() => {
-    const segments = [];
-    const structural = [];
-    for (const childId of childIds) {
-      const childNode = store.getNode(childId);
-      if (!childNode) continue;
-      if (childNode.type?.startsWith("list-item-")) {
-        segments.push(childId);
-      } else {
-        structural.push(childId);
-      }
-    }
-    return [segments, structural];
-  }, [childIds, store]);
-  const segmentElements = React5.useMemo(() => {
-    return segmentChildIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
-  }, [segmentChildIds, store, inlineComponents]);
-  const primaryContent = React5.useMemo(() => {
-    if (segmentChildIds.length > 0) {
-      return segmentElements;
-    }
-    return renderInlineNodes(inline, inlineComponents);
-  }, [segmentChildIds, segmentElements, inline, inlineComponents]);
-  const trailingChildren = React5.useMemo(() => {
-    return contentChildIds.map((childId) => {
-      const childNode = store.getNode(childId);
-      if (!childNode) return null;
-      switch (childNode.type) {
-        case "paragraph": {
-          const childInline = childNode.props?.inline ?? [];
-          return /* @__PURE__ */ jsx("p", { className: "markdown-list-item-paragraph", children: renderInlineNodes(childInline, inlineComponents) }, childId);
-        }
-        case "list":
-          return /* @__PURE__ */ jsx(ListBlockView, { store, blockId: childId, registry, depth: depth + 1 }, childId);
-        default:
-          return /* @__PURE__ */ jsx(BlockNodeRenderer, { store, blockId: childId, registry }, childId);
-      }
-    });
-  }, [contentChildIds, store, inlineComponents, registry, depth]);
-  const filteredChildren = trailingChildren.filter((child) => Boolean(child));
-  const hasChildren = filteredChildren.length > 0;
-  React5.useEffect(() => {
-    if (!listDebugEnabled) return;
-    const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
-    console.info("[stream-mdx:list-item-render]", {
-      itemId: nodeId,
-      depth,
-      ordered: isOrdered,
-      inferredIndex,
-      marker,
-      isTask,
-      isChecked,
-      childIds,
-      childTypes,
-      segmentChildIds,
-      contentChildIds,
-      inlineLength,
-      hasChildren,
-      isFinalized: block?.isFinalized ?? false
-    });
-  }, [
-    listDebugEnabled,
-    nodeId,
-    depth,
-    isOrdered,
-    inferredIndex,
-    marker,
-    isTask,
-    isChecked,
-    childIds,
-    segmentChildIds,
-    contentChildIds,
-    inlineLength,
-    hasChildren,
-    store,
-    block?.isFinalized
-  ]);
-  return /* @__PURE__ */ jsxs(
-    "li",
-    {
-      className: `markdown-list-item${isTask ? " markdown-list-item-task" : ""}`,
-      "data-counter-text": counterText,
-      "data-list-depth": depth,
-      "data-list-item-id": listDebugEnabled ? nodeId : void 0,
-      children: [
-        isTask ? /* @__PURE__ */ jsxs("div", { className: "markdown-task", children: [
-          /* @__PURE__ */ jsx("input", { type: "checkbox", className: "markdown-task-checkbox", checked: isChecked, readOnly: true, disabled: true, tabIndex: -1, "aria-checked": isChecked }),
-          /* @__PURE__ */ jsx("span", { className: "markdown-task-content", children: primaryContent })
-        ] }) : primaryContent,
-        hasChildren ? /* @__PURE__ */ jsx("div", { className: "markdown-list-item-children", children: filteredChildren }) : null
-      ]
-    }
-  );
-});
-ListItemView.displayName = "ListItemView";
-var TableBlockView = React5.memo(({ store, blockId, registry }) => {
-  const tableElements = registry.getTableElements();
-  const childIds = useRendererChildren(store, blockId);
-  return /* @__PURE__ */ jsx(tableElements.Table, { className: "markdown-table w-full caption-bottom text-base", children: childIds.map((sectionId) => /* @__PURE__ */ jsx(TableSectionView, { store, nodeId: sectionId, registry }, sectionId)) });
-});
-TableBlockView.displayName = "TableBlockView";
-var TableSectionView = React5.memo(({ store, nodeId, registry }) => {
-  const node = useRendererNode(store, nodeId);
-  if (!node) return null;
-  const tableElements = registry.getTableElements();
-  if (node.type === "table-header") {
-    const childIds = useRendererChildren(store, nodeId);
-    return /* @__PURE__ */ jsx(tableElements.Thead, { children: /* @__PURE__ */ jsx(tableElements.Tr, { children: childIds.map((cellId) => /* @__PURE__ */ jsx(TableCellView, { store, nodeId: cellId, registry }, cellId)) }) });
-  }
-  if (node.type === "table-body") {
-    const rowIds = useRendererChildren(store, nodeId);
-    return /* @__PURE__ */ jsx(tableElements.Tbody, { children: rowIds.map((rowId) => /* @__PURE__ */ jsx(TableRowView, { store, nodeId: rowId, registry }, rowId)) });
-  }
-  return null;
-});
-TableSectionView.displayName = "TableSectionView";
-var TableRowView = React5.memo(({ store, nodeId, registry }) => {
-  const tableElements = registry.getTableElements();
-  const cellIds = useRendererChildren(store, nodeId);
-  return /* @__PURE__ */ jsx(tableElements.Tr, { children: cellIds.map((cellId) => /* @__PURE__ */ jsx(TableCellView, { store, nodeId: cellId, registry }, cellId)) });
-});
-TableRowView.displayName = "TableRowView";
-var TableCellView = React5.memo(({ store, nodeId, registry }) => {
-  const node = useRendererNode(store, nodeId);
-  const inlineComponents = registry.getInlineComponents();
-  const tableElements = registry.getTableElements();
-  if (!node) return null;
-  const Tag = node.type === "table-header-cell" ? tableElements.Th : tableElements.Td;
-  const inline = node.props?.inline ?? [];
-  const align = node.props?.align;
-  const content = renderInlineNodes(inline, inlineComponents);
-  const alignProps = align ? { align } : void 0;
-  return /* @__PURE__ */ jsx(Tag, { ...alignProps, children: content });
-});
-TableCellView.displayName = "TableCellView";
-var CodeBlockView = React5.memo(({ store, blockId, registry }) => {
-  const node = useRendererNode(store, blockId);
-  const childIds = useRendererChildren(store, blockId);
-  const CodeComponent = registry.getBlockComponent("code");
-  const deferredConfig = React5.useContext(DeferredRenderContext);
-  const deferredRef = React5.useRef(null);
-  const shouldRenderDeferred = useDeferredRender(
-    deferredRef,
-    deferredConfig ? { ...deferredConfig, enabled: true } : { enabled: false }
-  );
-  if (!node || !node.block) return null;
-  const nodeVersion = node.version;
-  const lines = React5.useMemo(() => {
-    const seenIds = /* @__PURE__ */ new Set();
-    const seenIndices = /* @__PURE__ */ new Set();
-    const deduped = [];
-    for (const childId of childIds) {
-      const child = store.getNode(childId);
-      if (!child) continue;
-      const index = typeof child.props?.index === "number" ? child.props?.index : deduped.length;
-      const text = typeof child.props?.text === "string" ? child.props?.text : "";
-      const html = typeof child.props?.html === "string" ? child.props?.html : null;
-      const tokens = Object.prototype.hasOwnProperty.call(child.props ?? {}, "tokens") ? child.props?.tokens : void 0;
-      if (seenIds.has(child.id) || seenIndices.has(index)) {
-        console.warn("[renderer-view] duplicate code line detected", {
-          blockId,
-          childId: child.id,
-          index
-        });
-        continue;
-      }
-      seenIds.add(child.id);
-      seenIndices.add(index);
-      deduped.push({ id: child.id, index, text, html, tokens });
-    }
-    deduped.sort((a, b) => a.index - b.index);
-    return deduped;
-  }, [childIds, store, blockId, nodeVersion]);
-  const lang = typeof node.props?.lang === "string" ? node.props?.lang : node.block.payload.meta?.lang;
-  const preAttrs = node.props?.preAttrs ?? void 0;
-  const codeAttrs = node.props?.codeAttrs ?? void 0;
-  const virtualizationConfig = DEFAULT_VIRTUALIZED_CODE_CONFIG;
-  const virtualizationDisabled = typeof process !== "undefined" && typeof process.env === "object" && process.env.STREAM_MDX_DISABLE_VIRTUALIZED_CODE === "true";
-  const shouldVirtualize = !virtualizationDisabled && virtualizationConfig.enabled && lines.length >= virtualizationConfig.virtualizeThreshold;
-  const virtualization = useVirtualizedCode(lines, shouldVirtualize ? virtualizationConfig : { ...virtualizationConfig, enabled: false });
-  const highlightRequester = useCodeHighlightRequester();
-  const lazyEnabled = Boolean(node.block.payload.meta?.lazyTokenization);
-  const lazyTokenizedUntil = typeof node.block.payload.meta?.lazyTokenizedUntil === "number" ? node.block.payload.meta.lazyTokenizedUntil : 0;
-  const lastRangeRef = React5.useRef(null);
-  const rafRef = React5.useRef(null);
-  const idleRef = React5.useRef(null);
-  React5.useEffect(() => {
-    if (!shouldVirtualize || !lazyEnabled || !highlightRequester) return;
-    const { visibleStart, visibleEnd, startIndex, endIndex } = virtualization.window;
-    if (endIndex <= lazyTokenizedUntil) return;
-    const nextRange = {
-      visibleStart,
-      visibleEnd,
-      prefetchStart: startIndex,
-      prefetchEnd: endIndex,
-      tokenizedUntil: lazyTokenizedUntil
-    };
-    const last = lastRangeRef.current;
-    if (last && last.visibleStart === nextRange.visibleStart && last.visibleEnd === nextRange.visibleEnd && last.prefetchStart === nextRange.prefetchStart && last.prefetchEnd === nextRange.prefetchEnd && last.tokenizedUntil === nextRange.tokenizedUntil) {
-      return;
-    }
-    lastRangeRef.current = nextRange;
-    if (rafRef.current !== null && typeof cancelAnimationFrame === "function") {
-      cancelAnimationFrame(rafRef.current);
-    }
-    if (typeof requestAnimationFrame === "function") {
-      rafRef.current = requestAnimationFrame(() => {
-        highlightRequester({
-          blockId,
-          startLine: visibleStart,
-          endLine: visibleEnd,
-          priority: "visible",
-          reason: "scroll"
-        });
-        rafRef.current = null;
-      });
-    } else {
-      highlightRequester({
-        blockId,
-        startLine: visibleStart,
-        endLine: visibleEnd,
-        priority: "visible",
-        reason: "scroll"
-      });
-    }
-    const prefetchNeeded = startIndex < visibleStart || endIndex > visibleEnd;
-    if (prefetchNeeded) {
-      const idleCallback = globalThis.requestIdleCallback;
-      const cancelIdle = globalThis.cancelIdleCallback;
-      if (idleRef.current !== null) {
-        if (typeof cancelIdle === "function") {
-          cancelIdle(idleRef.current);
-        } else if (typeof clearTimeout === "function") {
-          clearTimeout(idleRef.current);
-        }
-      }
-      const schedule = () => {
-        highlightRequester({
-          blockId,
-          startLine: startIndex,
-          endLine: endIndex,
-          priority: "prefetch",
-          reason: "buffer"
-        });
-        idleRef.current = null;
-      };
-      if (typeof idleCallback === "function") {
-        idleRef.current = idleCallback(() => schedule());
-      } else if (typeof setTimeout === "function") {
-        idleRef.current = setTimeout(schedule, 80);
-      }
-    }
-  }, [
-    blockId,
-    highlightRequester,
-    lazyEnabled,
-    lazyTokenizedUntil,
-    shouldVirtualize,
-    virtualization.window.visibleStart,
-    virtualization.window.visibleEnd,
-    virtualization.window.startIndex,
-    virtualization.window.endIndex
-  ]);
-  const highlightedHtml = React5.useMemo(() => {
-    if (!shouldVirtualize && node.block?.payload.highlightedHtml) {
-      return node.block.payload.highlightedHtml;
-    }
-    if (lines.length > 0) {
-      const hasLineHtml = lines.some((line) => typeof line.html === "string" && line.html.length > 0);
-      if (!hasLineHtml && node.block?.payload.highlightedHtml) {
-        return node.block.payload.highlightedHtml;
-      }
-      if (shouldVirtualize) {
-        return composeHighlightedHtml(virtualization.window.visibleLines, preAttrs, codeAttrs);
-      }
-      return composeHighlightedHtml(lines, preAttrs, codeAttrs);
-    }
-    const blockHtml = node.block?.payload.highlightedHtml ?? "";
-    if (blockHtml?.trim().match(/^```[\w-]*\s*$/)) {
-      const raw = node.block?.payload.raw ?? "";
-      if (raw.trim().length > 0) {
-        return composeHighlightedHtml([{ index: 0, text: raw, html: null, id: "temp" }], preAttrs, codeAttrs);
-      }
-    }
-    return blockHtml;
-  }, [shouldVirtualize, node.block?.payload.highlightedHtml, lines, preAttrs, codeAttrs, virtualization.window.visibleLines, node.block?.payload.raw]);
-  const rendered = /* @__PURE__ */ jsx(
-    CodeComponent,
-    {
-      html: highlightedHtml,
-      meta: node.block.payload.meta,
-      lines: shouldVirtualize ? virtualization.window.visibleLines : lines,
-      lang,
-      preAttrs,
-      codeAttrs
-    }
-  );
-  const codeFrameClass = "not-prose flex flex-col rounded-lg border border-input pt-1 font-mono text-sm";
-  const codeMetricsAttrs = {
-    "data-code-block": "true",
-    "data-block-id": blockId,
-    "data-code-virtualized": shouldVirtualize ? "true" : "false",
-    "data-code-total-lines": String(lines.length),
-    "data-code-mounted-lines": String(shouldVirtualize ? virtualization.window.mountedLines : lines.length),
-    "data-code-window-size": String(virtualization.config.windowSize)
-  };
-  const codeView = shouldVirtualize ? (() => {
-    const { containerRef, window: window2, handleScroll, lineHeight } = virtualization;
-    const spacerTop = window2.startIndex * lineHeight;
-    const spacerBottom = (window2.totalLines - window2.endIndex) * lineHeight;
-    return /* @__PURE__ */ jsx("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: /* @__PURE__ */ jsxs(
-      "div",
-      {
-        ref: containerRef,
-        className: "markdown-code-block-container relative",
-        style: { overflowY: "auto", overflowX: "hidden", maxHeight: "600px" },
-        onScroll: handleScroll,
-        children: [
-          /* @__PURE__ */ jsx("div", { style: { height: spacerTop }, "aria-hidden": "true" }),
-          rendered,
-          /* @__PURE__ */ jsx("div", { style: { height: spacerBottom }, "aria-hidden": "true" })
-        ]
-      }
-    ) });
-  })() : /* @__PURE__ */ jsx("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: rendered });
-  const blockComponentMap = registry.getBlockComponentMap();
-  const MermaidComponent = Object.prototype.hasOwnProperty.call(blockComponentMap, "mermaid") ? blockComponentMap.mermaid : null;
-  if ((lang ?? "").toLowerCase() === "mermaid" && MermaidComponent) {
-    const raw = typeof node.block.payload.raw === "string" ? node.block.payload.raw : "";
-    const fenced = stripCodeFence(raw);
-    const code = fenced.hadFence ? fenced.code : raw;
-    if (deferredConfig) {
-      return /* @__PURE__ */ jsx("div", { ref: deferredRef, children: shouldRenderDeferred ? React5.createElement(MermaidComponent, {
-        code,
-        renderCode: codeView,
-        meta: node.block.payload.meta,
-        isFinalized: node.block.isFinalized
-      }) : codeView });
-    }
-    return React5.createElement(MermaidComponent, {
-      code,
-      renderCode: codeView,
-      meta: node.block.payload.meta,
-      isFinalized: node.block.isFinalized
-    });
-  }
-  return codeView;
-});
-CodeBlockView.displayName = "CodeBlockView";
-function composeHighlightedHtml(lines, preAttrs, codeAttrs) {
-  const lineMarkup = lines.map((line) => {
-    const content = line.html ?? escapeHtml(line.text);
-    const dataLine = Number.isFinite(line.index) ? ` data-line="${line.index + 1}"` : "";
-    return `<span class="line"${dataLine}>${content}</span>`;
-  }).join("\n");
-  const preAttr = attrsToString(preAttrs);
-  const codeAttr = attrsToString(codeAttrs);
-  return `<pre${preAttr}><code${codeAttr}>${lineMarkup}
-</code></pre>`;
-}
-function attrsToString(attrs) {
-  if (!attrs) return "";
-  return Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("");
-}
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function escapeAttribute(value) {
-  return value.replace(/"/g, "&quot;");
-}
-export {
-  BlockNodeRenderer
-};