{"version":3,"sources":["../src/core/limits.ts","../src/parser/StreamParser.ts","../src/server/index.ts"],"names":["a"],"mappings":"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","file":"server.cjs","sourcesContent":["/**\n * Hard limits to defend against pathological / adversarial input.\n * All values are overridable via parser options.\n */\n\nexport interface Limits {\n  /** Maximum total document length the parser will accept (default: 1 MB). */\n  maxDocLength: number;\n  /** Maximum nesting depth for inline tokens (bold/italic/etc). */\n  maxInlineDepth: number;\n  /** Maximum number of inline tokens a single block can produce. */\n  maxInlineTokens: number;\n  /** Maximum list nesting depth. */\n  maxListDepth: number;\n  /** Maximum table column count. */\n  maxTableColumns: number;\n}\n\nexport const DEFAULT_LIMITS: Limits = {\n  maxDocLength: 1_000_000,\n  maxInlineDepth: 4,\n  maxInlineTokens: 50_000,\n  maxListDepth: 10,\n  maxTableColumns: 100,\n};\n\nexport function clampText(text: string, limits: Pick<Limits, \"maxDocLength\">): string {\n  if (text.length <= limits.maxDocLength) return text;\n  return text.slice(0, limits.maxDocLength);\n}\n","/**\n * Streaming markdown block parser.\n *\n * Accepts the full accumulated text on each `push()`, diffs internally,\n * and produces a `Block[]` AST plus the index of the currently active\n * (still-streaming) block. Closed blocks are immutable so React can\n * memoize them safely.\n *\n * Supports: ATX + setext headings, paragraphs, fenced + indented code,\n * blockquotes, ordered/unordered/task lists with nesting, GFM tables\n * (committed only on separator-row), thematic breaks, horizontal rules,\n * hard limits, and prefix-change detection (auto-reset when the input\n * is no longer a prefix of what was last seen).\n */\n\nimport type {\n  Block,\n  BlockType,\n  BlockMeta,\n  ParseResult,\n  StreamMDOptions,\n  BlockPlugin,\n} from \"./types\";\nimport { DEFAULT_LIMITS, type Limits } from \"../core/limits\";\n\ninterface ParserOptions extends StreamMDOptions {\n  blockPlugins?: BlockPlugin[];\n}\n\nexport class StreamParser {\n  private blocks: Block[] = [];\n  private prevText = \"\";\n  private inCodeFence = false;\n  private codeFenceChar = \"\";\n  private codeFenceCount = 0;\n  private codeFenceIndent = 0;\n  private incompleteLine = \"\";\n  private blockId = 0;\n  private limits: Limits;\n  private opts: ParserOptions;\n\n  constructor(options: ParserOptions = {}) {\n    this.opts = options;\n    this.limits = { ...DEFAULT_LIMITS, ...(options.limits ?? {}) };\n  }\n\n  /**\n   * Push the full accumulated text. The parser internally diffs against\n   * the previous push to process only new content. If the new text is\n   * not a prefix of the previous text (e.g. consumer cleared / replaced\n   * the buffer), the parser resets and reparses from scratch.\n   */\n  push(fullText: string): ParseResult {\n    // Hard length cap to defend against pathological input.\n    if (fullText.length > this.limits.maxDocLength) {\n      fullText = fullText.slice(0, this.limits.maxDocLength);\n    }\n\n    if (fullText === this.prevText) {\n      return {\n        blocks: this.blocks,\n        activeIndex: this.blocks.length > 0 ? this.blocks.length - 1 : -1,\n      };\n    }\n\n    // Detect non-prefix change → reset.\n    const isPrefixGrow =\n      fullText.length >= this.prevText.length &&\n      fullText.startsWith(this.prevText);\n\n    if (!isPrefixGrow) {\n      this.reset();\n    }\n\n    const startedAt = this.prevText.length;\n    const newContent = fullText.slice(startedAt);\n    this.prevText = fullText;\n\n    // Re-process: keep any incompleteLine carry-over, append new content.\n    const buffer = this.incompleteLine + newContent;\n    const lines = buffer.split(\"\\n\");\n    // After splitting on \\n, the LAST element is either:\n    //   - the incomplete trailing text (no terminating \\n)\n    //   - the empty string \"\" left over from the final \\n\n    // Either way we must pop it; if it's the incomplete fragment, save it.\n    const lastIsIncomplete = !buffer.endsWith(\"\\n\");\n    const popped = lines.pop();\n    this.incompleteLine = lastIsIncomplete ? (popped ?? \"\") : \"\";\n\n    for (let li = 0; li < lines.length; li++) {\n      this.processLine(lines[li]!, lines, li);\n    }\n\n    return {\n      blocks: this.blocks,\n      activeIndex: this.blocks.length > 0 ? this.blocks.length - 1 : -1,\n    };\n  }\n\n  /** Get the current incomplete trailing line (for streaming display). */\n  getIncompleteLine(): string {\n    return this.incompleteLine;\n  }\n\n  /** Reset all state. */\n  reset(): void {\n    this.blocks = [];\n    this.prevText = \"\";\n    this.inCodeFence = false;\n    this.codeFenceChar = \"\";\n    this.codeFenceCount = 0;\n    this.codeFenceIndent = 0;\n    this.incompleteLine = \"\";\n    // blockId intentionally not reset so React keys remain stable across resets.\n  }\n\n  /** Get current blocks. */\n  getBlocks(): Block[] {\n    return this.blocks;\n  }\n\n  // ── Internals ──\n\n  private nextId(): string {\n    return \"smd-\" + ++this.blockId;\n  }\n\n  private getActive(): Block | null {\n    if (this.blocks.length === 0) return null;\n    const last = this.blocks[this.blocks.length - 1]!;\n    return last.closed ? null : last;\n  }\n\n  private closeActive(): void {\n    const a = this.getActive();\n    if (a) {\n      a.closed = true;\n      this.cacheParsed(a);\n      this.opts.onBlockComplete?.(a);\n    }\n  }\n\n  private startBlock(type: BlockType, content: string, meta: BlockMeta): Block {\n    const block: Block = {\n      id: this.nextId(),\n      type,\n      content,\n      closed: false,\n      meta,\n    };\n    this.blocks.push(block);\n    return block;\n  }\n\n  /**\n   * Cache parsed structure (e.g. table cells, list items) on close so\n   * components don't re-parse on every render.\n   */\n  private cacheParsed(block: Block): void {\n    if (block.type === \"table\") {\n      block.meta.parsed = parseTable(block.content);\n    } else if (block.type === \"list\") {\n      block.meta.parsed = parseListItems(block.content);\n    }\n  }\n\n  private processLine(line: string, allLines: string[], idx: number): void {\n    // ── Inside fenced code ──\n    if (this.inCodeFence) {\n      const stripped = line.replace(/^ {0,3}/, \"\");\n      if (this.isClosingFence(stripped)) {\n        this.inCodeFence = false;\n        this.closeActive();\n        return;\n      }\n      const a = this.getActive();\n      if (a && a.type === \"code\") {\n        // Strip up to fence-indent of leading spaces (CommonMark).\n        const indented = line.replace(\n          new RegExp(`^ {0,${this.codeFenceIndent}}`),\n          \"\",\n        );\n        a.content += (a.content ? \"\\n\" : \"\") + indented;\n      }\n      return;\n    }\n\n    // ── Plugin block matchers (run before builtins so they can override) ──\n    if (this.opts.blockPlugins?.length) {\n      for (const plugin of this.opts.blockPlugins) {\n        const m = plugin.openMatch(line);\n        if (m) {\n          this.closeActive();\n          const block = this.startBlock(m.type, m.content ?? \"\", {\n            ...(m.meta ?? {}),\n            pluginName: plugin.name,\n          });\n          if (m.closeImmediately) {\n            block.closed = true;\n            this.cacheParsed(block);\n            this.opts.onBlockComplete?.(block);\n          }\n          return;\n        }\n      }\n    }\n\n    // ── Blank line ──\n    if (line.trim() === \"\") {\n      this.closeActive();\n      return;\n    }\n\n    // ── Code fence opening ──\n    const fenceMatch = line.match(/^( {0,3})(`{3,}|~{3,})\\s*([^`]*)$/);\n    if (fenceMatch) {\n      // ` fences cannot contain ` in info string.\n      const fence = fenceMatch[2]!;\n      if (fence.startsWith(\"`\") && fenceMatch[3]!.includes(\"`\")) {\n        // fall through\n      } else {\n        this.closeActive();\n        this.inCodeFence = true;\n        this.codeFenceChar = fence[0]!;\n        this.codeFenceCount = fence.length;\n        this.codeFenceIndent = fenceMatch[1]!.length;\n        const info = fenceMatch[3]!.trim();\n        const spaceIdx = info.search(/\\s/);\n        const language = spaceIdx >= 0 ? info.slice(0, spaceIdx) : info;\n        const attributes = spaceIdx >= 0 ? info.slice(spaceIdx + 1) : \"\";\n        this.startBlock(\"code\", \"\", {\n          language,\n          ...(attributes ? { attributes } : {}),\n        });\n        return;\n      }\n    }\n\n    // ── ATX heading ──\n    const atxMatch = line.match(/^ {0,3}(#{1,6})(?:\\s+(.*?))?(?:\\s+#+)?\\s*$/);\n    if (atxMatch) {\n      this.closeActive();\n      const level = atxMatch[1]!.length;\n      const text = (atxMatch[2] ?? \"\").trim();\n      const block = this.startBlock(\"heading\", text, { level });\n      // Headings are always single-line — close immediately. (Premature\n      // closure of in-progress streaming heading lines is avoided because\n      // ATX-headings can only match on a fully complete line — incomplete\n      // lines stay in `incompleteLine` and don't reach processLine.)\n      block.closed = true;\n      this.opts.onBlockComplete?.(block);\n      return;\n    }\n\n    // ── Setext heading (look-back) ──\n    const setextMatch = line.match(/^ {0,3}(=+|-+)\\s*$/);\n    if (setextMatch) {\n      const active = this.getActive();\n      if (active && active.type === \"paragraph\" && !active.closed) {\n        active.type = \"heading\";\n        active.meta = { level: setextMatch[1]!.startsWith(\"=\") ? 1 : 2 };\n        active.closed = true;\n        this.opts.onBlockComplete?.(active);\n        return;\n      }\n      // Not setext → continue checking thematic break.\n    }\n\n    // ── Thematic break (HR) ──\n    if (/^ {0,3}([-*_])(?:\\s*\\1){2,}\\s*$/.test(line)) {\n      this.closeActive();\n      const block = this.startBlock(\"hr\", \"\", {});\n      block.closed = true;\n      this.opts.onBlockComplete?.(block);\n      return;\n    }\n\n    // ── Blockquote ──\n    const bqMatch = line.match(/^ {0,3}>\\s?(.*)$/);\n    if (bqMatch) {\n      const a = this.getActive();\n      if (a && a.type === \"blockquote\") {\n        a.content += \"\\n\" + bqMatch[1]!;\n      } else {\n        this.closeActive();\n        this.startBlock(\"blockquote\", bqMatch[1]!, {});\n      }\n      return;\n    }\n\n    // ── Lists (ordered + unordered, with nesting via indent) ──\n    const ulMatch = line.match(/^(\\s*)([-*+])\\s+(.*)$/);\n    const olMatch = line.match(/^(\\s*)(\\d{1,9})([.)])\\s+(.*)$/);\n    if (ulMatch || olMatch) {\n      const indent = (ulMatch ? ulMatch[1]! : olMatch![1]!).length;\n      const ordered = !!olMatch;\n      const a = this.getActive();\n      if (a && a.type === \"list\" && a.meta.ordered === ordered) {\n        a.content += \"\\n\" + line;\n        return;\n      }\n      this.closeActive();\n      const meta: BlockMeta = { ordered, indent };\n      if (ordered) meta.start = parseInt(olMatch![2]!, 10);\n      this.startBlock(\"list\", line, meta);\n      return;\n    }\n\n    // ── List continuation (indented line under a list) ──\n    {\n      const a = this.getActive();\n      if (a && a.type === \"list\" && /^\\s+\\S/.test(line)) {\n        a.content += \"\\n\" + line;\n        return;\n      }\n    }\n\n    // ── Indented code block (4 spaces, only when no active paragraph) ──\n    if (/^ {4}/.test(line)) {\n      const a = this.getActive();\n      if (!a || a.type === \"paragraph\" || a.type === \"code\") {\n        if (a && a.type === \"code\") {\n          a.content += \"\\n\" + line.slice(4);\n          return;\n        }\n        if (!a) {\n          this.startBlock(\"code\", line.slice(4), { language: \"\" });\n          return;\n        }\n      }\n      // Inside paragraph — fall through to paragraph append (lazy continuation).\n    }\n\n    // ── Table detection: only commits on separator row ──\n    if (line.includes(\"|\")) {\n      const a = this.getActive();\n      // Existing table → append.\n      if (a && a.type === \"table\") {\n        a.content += \"\\n\" + line;\n        return;\n      }\n      // Active paragraph + this line is a separator row matching column count?\n      if (\n        a &&\n        a.type === \"paragraph\" &&\n        a.content.includes(\"|\") &&\n        !a.content.includes(\"\\n\") &&\n        isTableSeparatorRow(line)\n      ) {\n        const headers = splitTableRow(a.content);\n        const seps = splitTableRow(line);\n        if (headers.length === seps.length && headers.length > 0) {\n          a.type = \"table\";\n          a.content += \"\\n\" + line;\n          return;\n        }\n      }\n      // Look-ahead: this line is a header and *next* line is a separator.\n      if (\n        !a ||\n        (a.type === \"paragraph\" && a.content.includes(\"\\n\") === false)\n      ) {\n        const next = allLines[idx + 1];\n        if (\n          next !== undefined &&\n          next.includes(\"|\") &&\n          isTableSeparatorRow(next)\n        ) {\n          const headers = splitTableRow(line);\n          const seps = splitTableRow(next);\n          if (headers.length === seps.length && headers.length > 0) {\n            this.closeActive();\n            this.startBlock(\"table\", line, {});\n            return;\n          }\n        }\n      }\n      // else fall through to paragraph\n    }\n\n    // ── HTML block (very limited; controlled by allowHtml) ──\n    if (this.opts.allowHtml && /^ {0,3}<[a-z!]/i.test(line)) {\n      const a = this.getActive();\n      if (a && a.type === \"html\") {\n        a.content += \"\\n\" + line;\n      } else {\n        this.closeActive();\n        this.startBlock(\"html\", line, {});\n      }\n      return;\n    }\n\n    // ── Paragraph (default) ──\n    const a = this.getActive();\n    if (a && a.type === \"paragraph\") {\n      a.content += \"\\n\" + line;\n    } else {\n      this.closeActive();\n      this.startBlock(\"paragraph\", line, {});\n    }\n  }\n\n  private isClosingFence(line: string): boolean {\n    if (line.length < this.codeFenceCount) return false;\n    let n = 0;\n    for (let i = 0; i < line.length; i++) {\n      if (line[i] === this.codeFenceChar) n++;\n      else if (line[i] === \" \" && n >= this.codeFenceCount) {\n        // trailing spaces ok\n        for (let j = i; j < line.length; j++) {\n          if (line[j] !== \" \") return false;\n        }\n        return true;\n      } else return false;\n    }\n    return n >= this.codeFenceCount;\n  }\n}\n\n// ── Helpers (also used by Blocks.tsx via meta.parsed cache) ──\n\nexport function isTableSeparatorRow(line: string): boolean {\n  const cells = splitTableRow(line);\n  if (cells.length === 0) return false;\n  return cells.every((c) => /^:?-+:?$/.test(c.trim()));\n}\n\nexport function splitTableRow(line: string): string[] {\n  const trimmed = line.trim().replace(/^\\||\\|$/g, \"\");\n  if (!trimmed) return [];\n  // Split on `|` but respect escaped `\\|`.\n  const out: string[] = [];\n  let buf = \"\";\n  for (let i = 0; i < trimmed.length; i++) {\n    const c = trimmed[i]!;\n    if (c === \"\\\\\" && trimmed[i + 1] === \"|\") {\n      buf += \"|\";\n      i++;\n    } else if (c === \"|\") {\n      out.push(buf.trim());\n      buf = \"\";\n    } else {\n      buf += c;\n    }\n  }\n  out.push(buf.trim());\n  return out;\n}\n\nexport interface ParsedTable {\n  headers: string[];\n  rows: string[][];\n  alignments: Array<\"left\" | \"center\" | \"right\" | \"none\">;\n}\n\nexport function parseTable(content: string): ParsedTable {\n  const lines = content.split(\"\\n\").filter((l) => l.trim() !== \"\");\n  if (lines.length === 0) return { headers: [], rows: [], alignments: [] };\n\n  const headers = splitTableRow(lines[0]!);\n  let alignments: ParsedTable[\"alignments\"] = headers.map(() => \"none\");\n  let dataStart = 1;\n\n  if (lines.length > 1 && isTableSeparatorRow(lines[1]!)) {\n    const aligns = splitTableRow(lines[1]!);\n    alignments = aligns.map((a) => {\n      const t = a.trim();\n      const left = t.startsWith(\":\");\n      const right = t.endsWith(\":\");\n      if (left && right) return \"center\";\n      if (right) return \"right\";\n      if (left) return \"left\";\n      return \"none\";\n    });\n    dataStart = 2;\n  }\n\n  const rows = lines.slice(dataStart).map(splitTableRow);\n  return { headers, rows, alignments };\n}\n\nexport interface ParsedListItem {\n  text: string;\n  isTask?: boolean;\n  taskChecked?: boolean;\n  indent: number;\n  children?: ParsedListItem[];\n}\n\nexport function parseListItems(content: string): ParsedListItem[] {\n  const lines = content.split(\"\\n\");\n  const flat: ParsedListItem[] = [];\n\n  for (const line of lines) {\n    const m = line.match(/^(\\s*)(?:[-*+]|\\d+[.)])\\s+(.*)$/);\n    if (!m) {\n      // Continuation line — append to last item's text.\n      const last = flat[flat.length - 1];\n      if (last) last.text += \"\\n\" + line.trim();\n      continue;\n    }\n    const indent = m[1]!.length;\n    let text = m[2]!;\n    let isTask: boolean | undefined;\n    let taskChecked: boolean | undefined;\n    const tm = text.match(/^\\[([ xX])\\]\\s+(.*)$/);\n    if (tm) {\n      isTask = true;\n      taskChecked = tm[1] !== \" \";\n      text = tm[2]!;\n    }\n    const item: ParsedListItem = { text, indent };\n    if (isTask !== undefined) {\n      item.isTask = isTask;\n      item.taskChecked = taskChecked;\n    }\n    flat.push(item);\n  }\n\n  // Build nested tree from indents.\n  return nestListItems(flat);\n}\n\nfunction nestListItems(flat: ParsedListItem[]): ParsedListItem[] {\n  const root: ParsedListItem[] = [];\n  const stack: { indent: number; list: ParsedListItem[] }[] = [\n    { indent: -1, list: root },\n  ];\n  for (const item of flat) {\n    while (stack.length > 1 && item.indent <= stack[stack.length - 1]!.indent) {\n      stack.pop();\n    }\n    const parent = stack[stack.length - 1]!.list;\n    parent.push(item);\n    stack.push({\n      indent: item.indent,\n      list: (item.children = item.children ?? []),\n    });\n  }\n  // Strip empty `children` arrays for cleanliness.\n  const strip = (items: ParsedListItem[]): ParsedListItem[] => {\n    for (const it of items) {\n      if (it.children && it.children.length === 0) delete it.children;\n      else if (it.children) strip(it.children);\n    }\n    return items;\n  };\n  return strip(root);\n}\n","/**\n * stream-md/server — RSC-safe server parser.\n *\n * Pure JS, no React, no DOM, no Node-only APIs. Runs in:\n *   - Node.js (server components, route handlers)\n *   - Edge runtime (Vercel Edge Functions, Cloudflare Workers)\n *   - Browsers / workers\n *\n * Returns plain `Block[]` data that is JSON-serializable, so it can cross\n * the RSC boundary without any \"this is not a plain object\" warnings.\n */\n\nimport { StreamParser } from \"../parser/StreamParser\";\nimport type { Block, StreamMDOptions } from \"../parser/types\";\n\n/**\n * One-shot parse: feed the entire markdown text and get the final blocks.\n *\n * Use this on the server when you have the full text already (e.g. a saved\n * assistant message) and want server-rendered HTML for first paint.\n */\nexport function parseToBlocks(\n  text: string,\n  options: StreamMDOptions = {},\n): Block[] {\n  const parser = new StreamParser(options);\n  parser.push(text);\n  // Force-close any trailing block so the result is fully finalized.\n  const blocks = parser.getBlocks();\n  for (const b of blocks) {\n    if (!b.closed) {\n      b.closed = true;\n      // Note: caches not populated here to keep the function cheap; consumers\n      // can call `parseTable(b.content)` etc. lazily.\n    }\n  }\n  // Strip any non-serializable fields just to be safe.\n  return blocks.map((b) => ({\n    id: b.id,\n    type: b.type,\n    content: b.content,\n    closed: b.closed,\n    meta: stripFunctions(b.meta) as Block[\"meta\"],\n  }));\n}\n\nfunction stripFunctions<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  if (Array.isArray(obj)) return obj.map(stripFunctions) as unknown as T;\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {\n    if (typeof v === \"function\") continue;\n    out[k] = stripFunctions(v);\n  }\n  return out as T;\n}\n\nexport { StreamParser } from \"../parser/StreamParser\";\nexport type { Block, BlockMeta, BlockType, StreamMDOptions } from \"../parser/types\";\n"]}