opentui-markdown-render 0.0.0-stage → 0.2.0

package/src/merman/core/drawing.ts

@@ -0,0 +1,307 @@
+import { BorderChars, type BorderCharacters } from "@opentui/core"
+import {
+  directionBetween,
+  walkOrthogonalSegment,
+  type DiagramBounds,
+  type DiagramDirection,
+  type DiagramPoint,
+} from "./geometry.js"
+
+export type DiagramLineCornerStyle = "square" | "rounded"
+export type DiagramLineStyle = "single" | "heavy" | "dashed"
+export type DiagramArrowHeadStyle = "filled" | "line"
+
+export interface DiagramDiamondCharacters {
+  topLeft: string
+  topRight: string
+  upperLeft: string
+  upperLeftJoin: string
+  upperRightJoin: string
+  upperRight: string
+  vertical: string
+  lowerLeft: string
+  lowerLeftJoin: string
+  lowerRightJoin: string
+  lowerRight: string
+  bottomLeft: string
+  bottomRight: string
+  horizontal: string
+}
+
+export const DIAGRAM_ARROW_HEADS = new Set(["▶", "◀", "▼", "▲", "→", "←", "↓", "↑"])
+const HEAVY_LINE_GLYPHS = new Set(Object.values(BorderChars.heavy))
+
+export const DIAGRAM_DIAMOND_CHARS = {
+  topLeft: "╭",
+  topRight: "╮",
+  upperLeft: "╭",
+  upperLeftJoin: "╯",
+  upperRightJoin: "╰",
+  upperRight: "╮",
+  vertical: "│",
+  lowerLeft: "╰",
+  lowerLeftJoin: "╮",
+  lowerRightJoin: "╭",
+  lowerRight: "╯",
+  bottomLeft: "╰",
+  bottomRight: "╯",
+  horizontal: "─",
+} as const satisfies DiagramDiamondCharacters
+
+export function diagramDiamondCharactersFromBorder(chars: BorderCharacters): DiagramDiamondCharacters {
+  return {
+    topLeft: chars.topLeft,
+    topRight: chars.topRight,
+    upperLeft: chars.topLeft,
+    upperLeftJoin: chars.bottomRight,
+    upperRightJoin: chars.bottomLeft,
+    upperRight: chars.topRight,
+    vertical: chars.vertical,
+    lowerLeft: chars.bottomLeft,
+    lowerLeftJoin: chars.topRight,
+    lowerRightJoin: chars.topLeft,
+    lowerRight: chars.bottomRight,
+    bottomLeft: chars.bottomLeft,
+    bottomRight: chars.bottomRight,
+    horizontal: chars.horizontal,
+  }
+}
+
+function lineDirections(char: string): readonly DiagramDirection[] | undefined {
+  switch (char) {
+    case "─":
+      return ["left", "right"]
+    case "│":
+      return ["up", "down"]
+    case "━":
+      return ["left", "right"]
+    case "┃":
+      return ["up", "down"]
+    case "┌":
+    case "╭":
+    case "┏":
+      return ["right", "down"]
+    case "┐":
+    case "╮":
+    case "┓":
+      return ["left", "down"]
+    case "└":
+    case "╰":
+    case "┗":
+      return ["up", "right"]
+    case "┘":
+    case "╯":
+    case "┛":
+      return ["up", "left"]
+    case "├":
+    case "┣":
+      return ["up", "down", "right"]
+    case "┤":
+    case "┫":
+      return ["up", "down", "left"]
+    case "┬":
+    case "┳":
+      return ["left", "right", "down"]
+    case "┴":
+    case "┻":
+      return ["left", "right", "up"]
+    case "┼":
+    case "╋":
+      return ["up", "down", "left", "right"]
+    default:
+      return undefined
+  }
+}
+
+export function diagramLineGlyph(
+  directions: ReadonlySet<DiagramDirection>,
+  cornerStyle: DiagramLineCornerStyle = "square",
+  lineStyle: DiagramLineStyle = "single",
+): string {
+  const up = directions.has("up")
+  const down = directions.has("down")
+  const left = directions.has("left")
+  const right = directions.has("right")
+  if (lineStyle === "heavy") {
+    const chars = BorderChars.heavy
+    if (up && down && left && right) return chars.cross
+    if (up && down && right) return chars.leftT
+    if (up && down && left) return chars.rightT
+    if (left && right && down) return chars.topT
+    if (left && right && up) return chars.bottomT
+    if (up && right) return chars.bottomLeft
+    if (up && left) return chars.bottomRight
+    if (down && right) return chars.topLeft
+    if (down && left) return chars.topRight
+    if (up || down) return chars.vertical
+    return chars.horizontal
+  }
+  if (up && down && left && right) return "┼"
+  if (up && down && right) return "├"
+  if (up && down && left) return "┤"
+  if (left && right && down) return "┬"
+  if (left && right && up) return "┴"
+  if (up && right) return cornerStyle === "rounded" ? "╰" : "└"
+  if (up && left) return cornerStyle === "rounded" ? "╯" : "┘"
+  if (down && right) return cornerStyle === "rounded" ? "╭" : "┌"
+  if (down && left) return cornerStyle === "rounded" ? "╮" : "┐"
+  if (up || down) return "│"
+  return "─"
+}
+
+function isHeavyLineGlyph(char: string): boolean {
+  return HEAVY_LINE_GLYPHS.has(char)
+}
+
+function segmentGlyph(direction: DiagramDirection, lineStyle: DiagramLineStyle | undefined): string {
+  const directions = new Set<DiagramDirection>(
+    direction === "left" || direction === "right" ? ["left", "right"] : ["up", "down"],
+  )
+  return diagramLineGlyph(directions, "square", lineStyle === "heavy" ? "heavy" : "single")
+}
+
+export function mergeDiagramLineGlyph(
+  existing: string,
+  incoming: string,
+  cornerStyle: DiagramLineCornerStyle = "square",
+): string | undefined {
+  const existingDirections = lineDirections(existing)
+  const incomingDirections = lineDirections(incoming)
+  if (!existingDirections || !incomingDirections) return undefined
+
+  return diagramLineGlyph(
+    new Set([...existingDirections, ...incomingDirections]),
+    cornerStyle,
+    isHeavyLineGlyph(existing) && isHeavyLineGlyph(incoming) ? "heavy" : "single",
+  )
+}
+
+export function diagramArrowHead(direction: DiagramDirection, style: DiagramArrowHeadStyle = "filled"): string {
+  if (style === "line") {
+    if (direction === "right") return "→"
+    if (direction === "left") return "←"
+    if (direction === "up") return "↑"
+    return "↓"
+  }
+
+  if (direction === "right") return "▶"
+  if (direction === "left") return "◀"
+  if (direction === "up") return "▲"
+  return "▼"
+}
+
+export function diagramArrowHeadBetween(
+  from: DiagramPoint,
+  to: DiagramPoint,
+  style: DiagramArrowHeadStyle = "filled",
+): string {
+  const direction = directionBetween(from, to)
+  return direction ? diagramArrowHead(direction, style) : diagramArrowHead("right", style)
+}
+
+export function drawDiagramFrame(
+  bounds: DiagramBounds,
+  chars: BorderCharacters,
+  setCell: (x: number, y: number, char: string) => void,
+): void {
+  setCell(bounds.left, bounds.top, chars.topLeft)
+  setCell(bounds.left + bounds.width - 1, bounds.top, chars.topRight)
+  setCell(bounds.left, bounds.top + bounds.height - 1, chars.bottomLeft)
+  setCell(bounds.left + bounds.width - 1, bounds.top + bounds.height - 1, chars.bottomRight)
+  for (let x = bounds.left + 1; x < bounds.left + bounds.width - 1; x++) {
+    setCell(x, bounds.top, chars.horizontal)
+    setCell(x, bounds.top + bounds.height - 1, chars.horizontal)
+  }
+  for (let y = bounds.top + 1; y < bounds.top + bounds.height - 1; y++) {
+    setCell(bounds.left, y, chars.vertical)
+    setCell(bounds.left + bounds.width - 1, y, chars.vertical)
+  }
+}
+
+export function fillDiagramFrameInterior(bounds: DiagramBounds, setCell: (x: number, y: number) => void): void {
+  for (let y = bounds.top + 1; y < bounds.top + bounds.height - 1; y++) {
+    for (let x = bounds.left + 1; x < bounds.left + bounds.width - 1; x++) setCell(x, y)
+  }
+}
+
+export function drawDiagramDiamond(
+  bounds: DiagramBounds,
+  setCell: (x: number, y: number, char: string) => void,
+  chars: DiagramDiamondCharacters = DIAGRAM_DIAMOND_CHARS,
+): void {
+  const left = bounds.left
+  const right = bounds.left + bounds.width - 1
+  const top = bounds.top
+  const bottom = bounds.top + bounds.height - 1
+  const capInset = Math.min(2, Math.max(1, Math.floor((bounds.width - 1) / 2)))
+  const capLeft = left + capInset
+  const capRight = right - capInset
+
+  setCell(capLeft, top, chars.topLeft)
+  for (let x = capLeft + 1; x < capRight; x++) setCell(x, top, chars.horizontal)
+  setCell(capRight, top, chars.topRight)
+
+  setCell(left, top + 1, chars.upperLeft)
+  for (let x = left + 1; x < capLeft; x++) setCell(x, top + 1, chars.horizontal)
+  setCell(capLeft, top + 1, chars.upperLeftJoin)
+  setCell(capRight, top + 1, chars.upperRightJoin)
+  for (let x = capRight + 1; x < right; x++) setCell(x, top + 1, chars.horizontal)
+  setCell(right, top + 1, chars.upperRight)
+
+  for (let y = top + 2; y < bottom - 1; y++) {
+    setCell(left, y, chars.vertical)
+    setCell(right, y, chars.vertical)
+  }
+
+  setCell(left, bottom - 1, chars.lowerLeft)
+  for (let x = left + 1; x < capLeft; x++) setCell(x, bottom - 1, chars.horizontal)
+  setCell(capLeft, bottom - 1, chars.lowerLeftJoin)
+  setCell(capRight, bottom - 1, chars.lowerRightJoin)
+  for (let x = capRight + 1; x < right; x++) setCell(x, bottom - 1, chars.horizontal)
+  setCell(right, bottom - 1, chars.lowerRight)
+
+  setCell(capLeft, bottom, chars.bottomLeft)
+  for (let x = capLeft + 1; x < capRight; x++) setCell(x, bottom, chars.horizontal)
+  setCell(capRight, bottom, chars.bottomRight)
+}
+
+export function drawOrthogonalPath(
+  points: readonly DiagramPoint[],
+  setCell: (x: number, y: number, char: string) => void,
+  options: { cornerStyle?: DiagramLineCornerStyle; lineStyle?: DiagramLineStyle } = {},
+): void {
+  for (let index = 1; index < points.length; index++) {
+    const from = points[index - 1]!
+    const to = points[index]!
+    const direction = directionBetween(from, to)
+    if (!direction) continue
+    const glyph = segmentGlyph(direction, options.lineStyle)
+    const horizontal = direction === "left" || direction === "right"
+    // Terminal cells are about twice as tall as they are wide. A two-cell
+    // horizontal dash matches the visual length of a one-row vertical dash,
+    // and the same ratio keeps the gaps balanced.
+    const dashOn = horizontal ? 2 : 1
+    const dashPeriod = horizontal ? 4 : 2
+    let step = index === 1 ? 0 : 1
+    walkOrthogonalSegment(from, to, index === 1, (point) => {
+      if (options.lineStyle !== "dashed" || step % dashPeriod < dashOn) setCell(point.x, point.y, glyph)
+      step += 1
+    })
+  }
+
+  for (let index = 1; index < points.length - 1; index++) {
+    const previous = points[index - 1]!
+    const current = points[index]!
+    const next = points[index + 1]!
+    const fromDirection = directionBetween(current, previous)
+    const toDirection = directionBetween(current, next)
+    const directions = new Set<DiagramDirection>()
+    if (fromDirection) directions.add(fromDirection)
+    if (toDirection) directions.add(toDirection)
+    setCell(
+      current.x,
+      current.y,
+      diagramLineGlyph(directions, options.cornerStyle, options.lineStyle === "heavy" ? "heavy" : "single"),
+    )
+  }
+}

package/src/merman/core/geometry.ts

@@ -0,0 +1,347 @@
+export type DiagramAxis = "x" | "y"
+export type DiagramDirection = "up" | "down" | "left" | "right"
+export type DiagramSide = "left" | "right" | "top" | "bottom"
+
+export interface DiagramPoint {
+  x: number
+  y: number
+}
+
+export interface DiagramBounds {
+  left: number
+  top: number
+  width: number
+  height: number
+  centerX: number
+  centerY: number
+}
+
+export interface DiagramSegment {
+  from: DiagramPoint
+  to: DiagramPoint
+  axis: DiagramAxis
+  direction: DiagramDirection
+  length: number
+}
+
+export interface DiagramLane {
+  axis: DiagramAxis
+  coordinate: number
+}
+
+export interface DiagramSpan {
+  start: number
+  end: number
+}
+
+const DIRECTION_AXIS = {
+  left: "x",
+  right: "x",
+  up: "y",
+  down: "y",
+} as const satisfies Record<DiagramDirection, DiagramAxis>
+
+const DIRECTION_SIGN = {
+  left: -1,
+  right: 1,
+  up: -1,
+  down: 1,
+} as const satisfies Record<DiagramDirection, -1 | 1>
+
+const DIRECTION_SIDE = {
+  left: "left",
+  right: "right",
+  up: "top",
+  down: "bottom",
+} as const satisfies Record<DiagramDirection, DiagramSide>
+
+const OPPOSITE_SIDE = {
+  left: "right",
+  right: "left",
+  top: "bottom",
+  bottom: "top",
+} as const satisfies Record<DiagramSide, DiagramSide>
+
+export function point(x: number, y: number): DiagramPoint {
+  return { x, y }
+}
+
+export function diagramBoundsFromRect(left: number, top: number, width: number, height: number): DiagramBounds {
+  return {
+    left,
+    top,
+    width,
+    height,
+    centerX: left + Math.floor(width / 2),
+    centerY: top + Math.floor(height / 2),
+  }
+}
+
+export function translateDiagramBounds(bounds: DiagramBounds, dx: number, dy: number): void {
+  bounds.left += dx
+  bounds.top += dy
+  bounds.centerX += dx
+  bounds.centerY += dy
+}
+
+export function diagramBoundsFromBounds(bounds: readonly DiagramBounds[]): DiagramBounds | undefined {
+  if (bounds.length === 0) return undefined
+  const left = Math.min(...bounds.map((bound) => bound.left))
+  const top = Math.min(...bounds.map((bound) => bound.top))
+  const right = Math.max(...bounds.map((bound) => bound.left + bound.width))
+  const bottom = Math.max(...bounds.map((bound) => bound.top + bound.height))
+  return diagramBoundsFromRect(left, top, right - left, bottom - top)
+}
+
+export function diagramBoundsFromPoints(points: readonly DiagramPoint[]): DiagramBounds | undefined {
+  if (points.length === 0) return undefined
+  const left = Math.min(...points.map((point) => point.x))
+  const top = Math.min(...points.map((point) => point.y))
+  const right = Math.max(...points.map((point) => point.x))
+  const bottom = Math.max(...points.map((point) => point.y))
+  return diagramBoundsFromRect(left, top, right - left + 1, bottom - top + 1)
+}
+
+export function coordinate(point: DiagramPoint, axis: DiagramAxis): number {
+  return point[axis]
+}
+
+export function withCoordinate(point: DiagramPoint, axis: DiagramAxis, value: number): DiagramPoint {
+  return axis === "x" ? { x: value, y: point.y } : { x: point.x, y: value }
+}
+
+export function shiftPoint(point: DiagramPoint, direction: DiagramDirection, distance = 1): DiagramPoint {
+  switch (direction) {
+    case "left":
+      return { x: point.x - distance, y: point.y }
+    case "right":
+      return { x: point.x + distance, y: point.y }
+    case "up":
+      return { x: point.x, y: point.y - distance }
+    case "down":
+      return { x: point.x, y: point.y + distance }
+  }
+}
+
+export function clampPoint(point: DiagramPoint, min: DiagramPoint = { x: 0, y: 0 }): DiagramPoint {
+  return { x: Math.max(min.x, point.x), y: Math.max(min.y, point.y) }
+}
+
+export function samePoint(left: DiagramPoint, right: DiagramPoint): boolean {
+  return left.x === right.x && left.y === right.y
+}
+
+export function directionAxis(direction: DiagramDirection): DiagramAxis {
+  return DIRECTION_AXIS[direction]
+}
+
+export function directionSign(direction: DiagramDirection): -1 | 1 {
+  return DIRECTION_SIGN[direction]
+}
+
+export function sideForDirection(direction: DiagramDirection): DiagramSide {
+  return DIRECTION_SIDE[direction]
+}
+
+export function oppositeSide(side: DiagramSide): DiagramSide {
+  return OPPOSITE_SIDE[side]
+}
+
+export function directionBetween(from: DiagramPoint, to: DiagramPoint): DiagramDirection | undefined {
+  if (from.y === to.y) {
+    if (to.x > from.x) return "right"
+    if (to.x < from.x) return "left"
+  }
+  if (from.x === to.x) {
+    if (to.y > from.y) return "down"
+    if (to.y < from.y) return "up"
+  }
+  return undefined
+}
+
+export function boundsCenter(bounds: DiagramBounds): DiagramPoint {
+  return point(bounds.centerX, bounds.centerY)
+}
+
+export function boundsSidePoint(
+  bounds: DiagramBounds,
+  side: DiagramSide,
+  surface: "border" | "outside" = "outside",
+): DiagramPoint {
+  switch (side) {
+    case "left":
+      return point(bounds.left - (surface === "outside" ? 1 : 0), bounds.centerY)
+    case "right":
+      return point(bounds.left + bounds.width - (surface === "outside" ? 0 : 1), bounds.centerY)
+    case "top":
+      return point(bounds.centerX, bounds.top - (surface === "outside" ? 1 : 0))
+    case "bottom":
+      return point(bounds.centerX, bounds.top + bounds.height - (surface === "outside" ? 0 : 1))
+  }
+}
+
+export function centerCoordinate(bounds: DiagramBounds, axis: DiagramAxis): number {
+  return axis === "x" ? bounds.centerX : bounds.centerY
+}
+
+export function snapCoordinate(source: number, target: number, tolerance: number): number {
+  return Math.abs(source - target) <= tolerance ? target : source
+}
+
+export function pathThrough(points: readonly DiagramPoint[]): DiagramPoint[] {
+  const path: DiagramPoint[] = []
+  for (const next of points) {
+    if (!path.length || !samePoint(path[path.length - 1]!, next)) path.push(point(next.x, next.y))
+  }
+  return path
+}
+
+export function lane(axis: DiagramAxis, coordinate: number): DiagramLane {
+  return { axis, coordinate }
+}
+
+export function pathViaLane(start: DiagramPoint, routeLane: DiagramLane, end: DiagramPoint): DiagramPoint[] {
+  return pathThrough([
+    start,
+    withCoordinate(start, routeLane.axis, routeLane.coordinate),
+    withCoordinate(end, routeLane.axis, routeLane.coordinate),
+    end,
+  ])
+}
+
+function dominantAxis(start: DiagramPoint, end: DiagramPoint): DiagramAxis {
+  return Math.abs(end.x - start.x) >= Math.abs(end.y - start.y) ? "x" : "y"
+}
+
+function terminalLane(start: DiagramPoint, end: DiagramPoint, axis: DiagramAxis, terminalClearance: number): number {
+  const startCoordinate = coordinate(start, axis)
+  const endCoordinate = coordinate(end, axis)
+  const delta = endCoordinate - startCoordinate
+  const sign = Math.sign(delta)
+  if (sign === 0) return endCoordinate
+  return endCoordinate - sign * Math.min(terminalClearance, Math.max(1, Math.abs(delta) - 1))
+}
+
+export function orthogonalPath(
+  start: DiagramPoint,
+  end: DiagramPoint,
+  options: { preferredAxis?: DiagramAxis; terminalClearance?: number } = {},
+): DiagramPoint[] {
+  if (start.x === end.x || start.y === end.y) return pathThrough([start, end])
+
+  const laneAxis = options.preferredAxis ?? dominantAxis(start, end)
+  return pathViaLane(start, lane(laneAxis, terminalLane(start, end, laneAxis, options.terminalClearance ?? 4)), end)
+}
+
+export function segmentBetween(from: DiagramPoint, to: DiagramPoint): DiagramSegment | undefined {
+  const direction = directionBetween(from, to)
+  if (!direction) return undefined
+  return {
+    from,
+    to,
+    axis: directionAxis(direction),
+    direction,
+    length: Math.abs(coordinate(to, directionAxis(direction)) - coordinate(from, directionAxis(direction))),
+  }
+}
+
+export function walkOrthogonalSegment(
+  from: DiagramPoint,
+  to: DiagramPoint,
+  includeStart: boolean,
+  visit: (point: DiagramPoint) => boolean | void,
+): void {
+  const direction = directionBetween(from, to)
+  if (!direction) return
+
+  const dx = direction === "right" ? 1 : direction === "left" ? -1 : 0
+  const dy = direction === "down" ? 1 : direction === "up" ? -1 : 0
+  let cursor = includeStart ? from : point(from.x + dx, from.y + dy)
+
+  while (!samePoint(cursor, to)) {
+    if (visit(cursor) === false) return
+    cursor = point(cursor.x + dx, cursor.y + dy)
+  }
+}
+
+export function orthogonalPathPoints(points: readonly DiagramPoint[]): DiagramPoint[] {
+  const path: DiagramPoint[] = []
+  for (let index = 1; index < points.length; index++) {
+    const from = points[index - 1]!
+    const to = points[index]!
+    const direction = directionBetween(from, to)
+    if (!direction) continue
+
+    const dx = direction === "right" ? 1 : direction === "left" ? -1 : 0
+    const dy = direction === "down" ? 1 : direction === "up" ? -1 : 0
+    let cursor = path.length === 0 ? point(from.x, from.y) : point(from.x + dx, from.y + dy)
+    while (true) {
+      path.push(cursor)
+      if (samePoint(cursor, to)) break
+      cursor = point(cursor.x + dx, cursor.y + dy)
+    }
+  }
+  return path
+}
+
+export function orderedSpan(left: number, right: number): DiagramSpan {
+  return left <= right ? { start: left, end: right } : { start: right, end: left }
+}
+
+export function segmentSpan(segment: DiagramSegment): DiagramSpan {
+  return orderedSpan(coordinate(segment.from, segment.axis), coordinate(segment.to, segment.axis))
+}
+
+export function pointOnSegment(segment: DiagramSegment, coordinateValue: number): DiagramPoint {
+  return withCoordinate(segment.from, segment.axis, coordinateValue)
+}
+
+export function insetSpan(span: DiagramSpan, amount: number): DiagramSpan {
+  return { start: span.start + amount, end: span.end - amount }
+}
+
+export function spanCapacity(span: DiagramSpan): number {
+  return Math.max(0, span.end - span.start + 1)
+}
+
+export function centeredSpanStart(span: DiagramSpan, width: number): number {
+  return span.start + Math.floor((spanCapacity(span) - width) / 2)
+}
+
+export function midpoint(span: DiagramSpan): number {
+  return Math.round((span.start + span.end) / 2)
+}
+
+export function advanceCoordinate(origin: number, direction: DiagramDirection, distance: number): number {
+  return origin + directionSign(direction) * distance
+}
+
+export function beforeNearestCoordinate(
+  points: readonly DiagramPoint[],
+  axis: DiagramAxis,
+  direction: DiagramDirection,
+  clearance: number,
+): number {
+  const coordinates = points.map((point) => coordinate(point, axis))
+  const nearest = directionSign(direction) > 0 ? Math.min(...coordinates) : Math.max(...coordinates)
+  return advanceCoordinate(nearest, direction, -clearance)
+}
+
+export function afterFarthestCoordinate(
+  points: readonly DiagramPoint[],
+  axis: DiagramAxis,
+  direction: DiagramDirection,
+  clearance: number,
+): number {
+  const coordinates = points.map((point) => coordinate(point, axis))
+  const farthest = directionSign(direction) > 0 ? Math.max(...coordinates) : Math.min(...coordinates)
+  return advanceCoordinate(farthest, direction, clearance)
+}
+
+export function keepBefore(preferred: number, boundary: number, direction: DiagramDirection): number {
+  return directionSign(direction) > 0 ? Math.min(preferred, boundary) : Math.max(preferred, boundary)
+}
+
+export function keepAfter(preferred: number, boundary: number, direction: DiagramDirection): number {
+  return directionSign(direction) > 0 ? Math.max(preferred, boundary) : Math.min(preferred, boundary)
+}

package/src/merman/core/mermaid.ts

@@ -0,0 +1,38 @@
+export interface NumberedMermaidLine {
+  readonly lineNumber: number
+  readonly text: string
+}
+
+export function* numberedMermaidLines(content: string): Generator<NumberedMermaidLine> {
+  const lines = content.split(/\r?\n/)
+  for (let index = 0; index < lines.length; index += 1) {
+    yield { lineNumber: index + 1, text: lines[index]!.trim() }
+  }
+}
+
+export function* meaningfulNumberedMermaidLines(content: string): Generator<NumberedMermaidLine> {
+  for (const line of numberedMermaidLines(content)) {
+    if (line.text && !line.text.startsWith("%%")) yield line
+  }
+}
+
+export function firstMeaningfulMermaidLine(content: string): string | undefined {
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (line && !line.startsWith("%%")) return line
+  }
+  return undefined
+}
+
+export function stripMermaidQuotes(value: string): string {
+  const trimmed = value.trim()
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return decodeMermaidText(trimmed.slice(1, -1))
+  }
+  return decodeMermaidText(trimmed)
+}
+
+export function decodeMermaidText(value: string): string {
+  return decodeHTMLStrict(value)
+}
+import { decodeHTMLStrict } from "entities"