capture-flow 0.0.0-stage → 0.1.0

package/vendor/wajha/engine/geometry.ts

@@ -0,0 +1,152 @@
+/**
+ * Numeric and path helpers shared by the engine's painters. Everything here
+ * is defensive: layouts come from user files, so NaN, negative sizes and
+ * huge values must be turned into something the canvas accepts (several
+ * Canvas 2D calls throw on negative radii).
+ */
+import type { Ctx2D } from './types';
+
+export const DEG = Math.PI / 180;
+export const TAU = Math.PI * 2;
+
+export interface Rect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+export const clamp = (v: number, lo: number, hi: number): number => (v < lo ? lo : v > hi ? hi : v);
+
+/** `v` when it is a finite number, else `fallback`. */
+export function num(v: unknown, fallback: number): number {
+  return typeof v === 'number' && Number.isFinite(v) ? v : fallback;
+}
+
+/** Overlap of two rectangles, or null when they do not intersect. */
+export function intersect(a: Rect, b: Rect): Rect | null {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const r = Math.min(a.x + a.w, b.x + b.w);
+  const bottom = Math.min(a.y + a.h, b.y + b.h);
+  return r > x && bottom > y ? { x, y, w: r - x, h: bottom - y } : null;
+}
+
+/**
+ * Adds a rounded-rectangle sub-path. Uses `ctx.roundRect` when present
+ * (missing in older WebKit) and an arc-based fallback otherwise; the radius
+ * is clamped to half the shorter side like CSS does.
+ */
+export function roundedRect(ctx: Ctx2D, x: number, y: number, w: number, h: number, r: number): void {
+  if (!(w > 0) || !(h > 0)) return;
+  const rr = clamp(num(r, 0), 0, Math.min(w, h) / 2);
+  if (rr <= 0) {
+    ctx.rect(x, y, w, h);
+    return;
+  }
+  if (typeof ctx.roundRect === 'function') {
+    ctx.roundRect(x, y, w, h, rr);
+    return;
+  }
+  ctx.moveTo(x + rr, y);
+  ctx.lineTo(x + w - rr, y);
+  ctx.arc(x + w - rr, y + rr, rr, -Math.PI / 2, 0);
+  ctx.lineTo(x + w, y + h - rr);
+  ctx.arc(x + w - rr, y + h - rr, rr, 0, Math.PI / 2);
+  ctx.lineTo(x + rr, y + h);
+  ctx.arc(x + rr, y + h - rr, rr, Math.PI / 2, Math.PI);
+  ctx.lineTo(x, y + rr);
+  ctx.arc(x + rr, y + rr, rr, Math.PI, Math.PI * 1.5);
+  ctx.closePath();
+}
+
+/** Adds an axis-aligned ellipse sub-path centred on (cx, cy); `ccw` reverses the winding (for rings). */
+export function ellipsePath(ctx: Ctx2D, cx: number, cy: number, rx: number, ry: number, ccw = false): void {
+  if (!(rx > 0) || !(ry > 0)) return;
+  // A fresh sub-path, so a second ellipse (ring hole) is not joined to the first by a line.
+  ctx.moveTo(cx + rx, cy);
+  // The spec only guarantees a full turn when the sweep in the drawing direction is >= 2π,
+  // so counter-clockwise runs from 2π down to 0 rather than relying on angle normalisation.
+  if (ccw) ctx.ellipse(cx, cy, rx, ry, 0, TAU, 0, true);
+  else ctx.ellipse(cx, cy, rx, ry, 0, 0, TAU, false);
+  ctx.closePath();
+}
+
+export interface GradientLine {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+}
+
+/**
+ * Gradient line of a CSS `linear-gradient(<angle>)` over a box: it passes
+ * through the centre, 0deg points up, 90deg right, and its length is
+ * |w sin a| + |h cos a| so the corners get exactly the first/last stop.
+ */
+export function linearGradientLine(angleDeg: number, box: Rect): GradientLine {
+  const a = num(angleDeg, 180) * DEG;
+  const dx = Math.sin(a);
+  const dy = -Math.cos(a);
+  const half = (Math.abs(box.w * dx) + Math.abs(box.h * dy)) / 2;
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  return { x0: cx - dx * half, y0: cy - dy * half, x1: cx + dx * half, y1: cy + dy * half };
+}
+
+/** Deterministic PRNG (mulberry32): same seed, same sequence, on every platform. */
+export function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Integer seed from any number; NaN and Infinity become 0. */
+export function seedInt(seed: unknown): number {
+  const s = num(seed, 0);
+  return Math.abs(s) < 2 ** 31 ? Math.floor(s) | 0 : (Math.floor(s % 2 ** 32) | 0);
+}
+
+/** Stateless hash of a lattice point to [0, 1); used for film grain. */
+export function hash2(x: number, y: number, seed = 0): number {
+  let h = Math.imul(x | 0, 0x27d4eb2d) ^ Math.imul(y | 0, 0x165667b1) ^ Math.imul(seed | 0, 0x9e3779b1);
+  h = Math.imul(h ^ (h >>> 15), 0x85ebca6b);
+  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
+  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
+}
+
+/**
+ * Runs `draw` with bilinear image sampling. Soft content (mesh bitmaps,
+ * glows, blurred images) and ~1:1 pattern tiles look identical to the
+ * 'high' quality filter but cost a fraction of it on CPU rasterisers.
+ */
+export function withFastSampling(ctx: Ctx2D, draw: () => void): void {
+  const prev = ctx.imageSmoothingQuality;
+  ctx.imageSmoothingQuality = 'low';
+  try {
+    draw();
+  } finally {
+    ctx.imageSmoothingQuality = prev;
+  }
+}
+
+/**
+ * Uniform scale of the context's current transform (device pixels per user
+ * unit). Shadow blur and offsets ignore the transform, so painters multiply
+ * them by this to stay proportional when a caller renders scaled.
+ */
+export function transformScale(ctx: Ctx2D): number {
+  if (typeof ctx.getTransform !== 'function') return 1;
+  try {
+    const t = ctx.getTransform();
+    const s = Math.sqrt(Math.abs(t.a * t.d - t.b * t.c));
+    return Number.isFinite(s) && s > 1e-6 ? s : 1;
+  } catch {
+    return 1;
+  }
+}

package/vendor/wajha/engine/images.ts

@@ -0,0 +1,96 @@
+/**
+ * Image elements: a picture `width x u` wide with the asset's aspect, clipped
+ * to rounded corners, with an optional shadow. The shadow follows CSS
+ * box-shadow rules: it is cast by the rounded box and only shows outside
+ * it, so a transparent PNG never reveals a dark rectangle behind itself.
+ */
+import type { ImageElement } from '../model/types';
+import type { Ctx2D, ImageLike } from './types';
+import { cssColor } from './paint';
+import { clamp, num, roundedRect } from './geometry';
+
+/** Fill of an image element whose picture is not decoded (or missing). */
+export const MISSING_IMAGE_FILL = 'rgba(148, 154, 166, 0.22)';
+
+export interface ImageSources {
+  getImage(assetId: string): ImageLike | null;
+  getAssetAspect(assetId: string): number | null;
+}
+
+function safeCall<T>(fn: () => T, fallback: T): T {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+
+/** Decoded image (or null) and height/width aspect of an image element's asset. */
+export function resolveImage(el: ImageElement, src: ImageSources): { image: ImageLike | null; aspect: number } {
+  const id = typeof el.assetId === 'string' ? el.assetId : '';
+  const raw = id ? safeCall(() => src.getImage(id), null) : null;
+  const image = raw && raw.width > 0 && raw.height > 0 ? raw : null;
+  const known = id ? safeCall(() => src.getAssetAspect(id), null) : null;
+  let aspect = num(known, 0);
+  if (!(aspect > 0) && image) aspect = image.height / image.width;
+  if (!(aspect > 0) || !Number.isFinite(aspect)) aspect = 1;
+  return { image, aspect: clamp(aspect, 0.02, 50) };
+}
+
+/**
+ * Draws an image element centred on the origin. Returns its unrotated size
+ * in pixels. `pxScale` converts shadow sizes to device pixels.
+ */
+export function drawImageElement(ctx: Ctx2D, el: ImageElement, u: number, pxScale: number, src: ImageSources): { w: number; h: number } {
+  const { image, aspect } = resolveImage(el, src);
+  const w = Math.max(0, num(el.width, 0) * u);
+  const h = w * aspect;
+  if (!(w >= 0.5) || !(h >= 0.5) || !Number.isFinite(w * h)) return { w, h };
+  const x = -w / 2;
+  const y = -h / 2;
+  const r = clamp(num(el.cornerRadius, 0), 0, 0.5) * w;
+
+  if (!image) {
+    ctx.fillStyle = MISSING_IMAGE_FILL;
+    ctx.beginPath();
+    roundedRect(ctx, x, y, w, h, r);
+    ctx.fill();
+    return { w, h };
+  }
+
+  const sh = el.shadow;
+  if (sh && typeof sh === 'object') {
+    ctx.save();
+    try {
+      // Clip to everything outside the box; the filled box itself is then invisible and
+      // only its shadow remains (no off-canvas trick needed, so rotation is free).
+      const big = 1e6;
+      ctx.beginPath();
+      ctx.rect(-big, -big, 2 * big, 2 * big);
+      roundedRect(ctx, x, y, w, h, r);
+      ctx.clip('evenodd');
+      ctx.shadowColor = cssColor(sh.color);
+      ctx.shadowBlur = Math.max(0, num(sh.blur, 0)) * u * pxScale;
+      ctx.shadowOffsetX = num(sh.x, 0) * u * pxScale;
+      ctx.shadowOffsetY = num(sh.y, 0) * u * pxScale;
+      ctx.fillStyle = '#000000';
+      ctx.beginPath();
+      roundedRect(ctx, x, y, w, h, r);
+      ctx.fill();
+    } finally {
+      ctx.restore();
+    }
+  }
+
+  ctx.save();
+  try {
+    ctx.beginPath();
+    roundedRect(ctx, x, y, w, h, r);
+    ctx.clip();
+    // Throws for a bitmap the image cache closed meanwhile; the finally keeps the stack balanced.
+    ctx.drawImage(image, x, y, w, h);
+  } finally {
+    ctx.restore();
+  }
+  return { w, h };
+}

package/vendor/wajha/engine/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Engine entry point. Implementations live in sibling modules:
+ *   render.ts      renderSlide (scene composition)
+ *   background.ts  slide backgrounds incl. panorama windows
+ *   paint.ts       the Fill painter (solid, linear, radial, mesh, image)
+ *   patterns.ts    background patterns
+ *   shapes.ts      circle / rect / blob / ring, soft glows
+ *   images.ts      image elements
+ *   text.ts        layoutText / drawTextBlock (markup.ts, linebreak.ts, bidi.ts)
+ *   devices/       deviceGeometry / drawDevice
+ *   mock.ts        drawMockScreen
+ *   cache.ts       bounded caches shared by the painters
+ */
+export type * from './types';
+export { deviceScreenAspect, mockSeed, renderSlide } from './render';
+export { layoutText } from './text';
+export { deviceGeometry, drawDevice } from './devices';
+export { drawMockScreen } from './mock';
+export { parseMarkup, plainText } from './markup';
+export { clearEngineCaches } from './cache';

package/vendor/wajha/engine/linebreak.ts

@@ -0,0 +1,226 @@
+/**
+ * Where a paragraph may wrap. A simplified UAX #14:
+ *  - after spaces (the spaces hang at the line end and are not drawn),
+ *  - after a hyphen inside a word ("state-of-the-art"),
+ *  - around ideographs, kana and fullwidth forms in any language,
+ *  - between any graphemes for languages marked `wrap: 'char'`, except
+ *    inside runs of Latin-like letters and digits, so an app name inside
+ *    Japanese copy stays whole; Thai uses dictionary word boundaries from
+ *    Intl.Segmenter when available,
+ *  - never before closing punctuation or small kana, never after opening
+ *    punctuation (basic kinsoku shori).
+ * Graphemes come from Intl.Segmenter, with a code-point fallback that keeps
+ * combining marks, variation selectors, ZWJ emoji and flags together, so a
+ * forced break can never split a user-perceived character.
+ */
+
+/** Break class of a grapheme. */
+const WSP = 0; // breaking whitespace
+const ZW = 1; // zero-width space: break opportunity
+const CL = 2; // closing punctuation: no break before
+const OP = 3; // opening punctuation: no break after
+const HY = 4; // hyphen: break after (inside words)
+const ID = 5; // ideographic: break before and after
+const SA = 6; // Thai/Lao/Khmer/Myanmar: no spaces between words
+const AL = 7; // letters, digits, everything else: no break inside
+
+export interface Segment {
+  /** First code unit of the segment. */
+  start: number;
+  /** End of the visible content (exclusive), before any trailing spaces. */
+  end: number;
+  /** End including trailing spaces. */
+  wsEnd: number;
+}
+
+export interface Segmentation {
+  /** Grapheme start offsets, followed by text.length. */
+  graphemes: number[];
+  segments: Segment[];
+}
+
+type Granularity = 'grapheme' | 'word';
+const segmenters = new Map<string, Intl.Segmenter | null>();
+
+function segmenter(lang: string, granularity: Granularity): Intl.Segmenter | null {
+  const key = `${granularity}|${lang}`;
+  const hit = segmenters.get(key);
+  if (hit !== undefined) return hit;
+  let seg: Intl.Segmenter | null = null;
+  if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
+    try {
+      seg = new Intl.Segmenter(lang || undefined, { granularity });
+    } catch {
+      // Invalid language tags throw RangeError; fall back to the default locale.
+      try {
+        seg = new Intl.Segmenter(undefined, { granularity });
+      } catch {
+        seg = null;
+      }
+    }
+  }
+  if (segmenters.size > 64) segmenters.clear();
+  segmenters.set(key, seg);
+  return seg;
+}
+
+const isExtender = (cp: number) =>
+  (cp >= 0x0300 && cp <= 0x036f) || // combining diacritics
+  (cp >= 0x0483 && cp <= 0x0489) ||
+  (cp >= 0x0591 && cp <= 0x05c7 && cp !== 0x05be && cp !== 0x05c0 && cp !== 0x05c3 && cp !== 0x05c6) ||
+  (cp >= 0x0610 && cp <= 0x061a) ||
+  (cp >= 0x064b && cp <= 0x065f) ||
+  cp === 0x0670 ||
+  (cp >= 0x06d6 && cp <= 0x06ed && cp !== 0x06dd && cp !== 0x06de && cp !== 0x06e5 && cp !== 0x06e6 && cp !== 0x06e9) ||
+  (cp >= 0x0900 && cp <= 0x0903) ||
+  (cp >= 0x093a && cp <= 0x094f) ||
+  cp === 0x0e31 ||
+  (cp >= 0x0e34 && cp <= 0x0e3a) ||
+  (cp >= 0x0e47 && cp <= 0x0e4e) ||
+  (cp >= 0x1ab0 && cp <= 0x1aff) ||
+  (cp >= 0x1dc0 && cp <= 0x1dff) ||
+  cp === 0x200c ||
+  cp === 0x200d ||
+  (cp >= 0x20d0 && cp <= 0x20ff) ||
+  (cp >= 0x3099 && cp <= 0x309a) ||
+  (cp >= 0xfe00 && cp <= 0xfe0f) ||
+  (cp >= 0xfe20 && cp <= 0xfe2f) ||
+  (cp >= 0x1f3fb && cp <= 0x1f3ff) || // skin tones
+  (cp >= 0xe0020 && cp <= 0xe007f) || // emoji tags
+  (cp >= 0xe0100 && cp <= 0xe01ef);
+
+const isRegionalIndicator = (cp: number) => cp >= 0x1f1e6 && cp <= 0x1f1ff;
+
+/**
+ * Grapheme starts without Intl.Segmenter (older WebKit): combining marks,
+ * variation selectors, skin tones, ZWJ sequences and flag pairs stay with
+ * the character before them. Followed by text.length.
+ */
+export function fallbackGraphemeBounds(text: string): number[] {
+  const out: number[] = [];
+  let prevZwj = false;
+  let riRun = 0;
+  for (let i = 0; i < text.length; ) {
+    const cp = text.codePointAt(i) ?? 0;
+    const ri = isRegionalIndicator(cp);
+    // Flags are pairs of regional indicators: the 2nd, 4th, ... join the one before.
+    const joins = i > 0 && (isExtender(cp) || prevZwj || (ri && riRun % 2 === 1));
+    if (!joins) out.push(i);
+    riRun = ri ? riRun + 1 : 0;
+    prevZwj = cp === 0x200d;
+    i += cp > 0xffff ? 2 : 1;
+  }
+  out.push(text.length);
+  return out;
+}
+
+/** Grapheme start offsets (UTF-16) followed by text.length. */
+export function graphemeBounds(text: string, lang: string): number[] {
+  if (!text) return [0];
+  const seg = segmenter(lang, 'grapheme');
+  if (!seg) return fallbackGraphemeBounds(text);
+  const out: number[] = [];
+  for (const s of seg.segment(text)) out.push(s.index);
+  out.push(text.length);
+  return out;
+}
+
+/** Splits a string into graphemes. */
+export function graphemes(text: string, lang: string): string[] {
+  const b = graphemeBounds(text, lang);
+  const out: string[] = [];
+  for (let i = 0; i + 1 < b.length; i++) out.push(text.slice(b[i], b[i + 1]));
+  return out;
+}
+
+const CLOSERS = new Set(
+  [...')]}»›”’"\'!?,.:;…‼⁇⁈⁉、。，．！？：；）］｝〕〉》」』】〙〗〟｠ー々〻ぁぃぅぇぉっゃゅょゎゕゖァィゥェォッャュョヮヵヶㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ・‥゛゜ゝゞヽヾ％‰°′″℃¢؟،؛'].map(
+    (c) => c.codePointAt(0) ?? 0,
+  ),
+);
+const OPENERS = new Set([...'([{«‹“‘（［｛〔〈《「『【〘〖〝｟'].map((c) => c.codePointAt(0) ?? 0));
+
+const LETTER = /\p{L}/u;
+
+function breakClass(cp: number): number {
+  if (cp === 0x20 || cp === 0x09 || cp === 0x3000 || cp === 0x1680 || (cp >= 0x2000 && cp <= 0x2006) || (cp >= 0x2008 && cp <= 0x200a) || cp === 0x205f) return WSP;
+  if (cp === 0x200b) return ZW;
+  if (CLOSERS.has(cp)) return CL;
+  if (OPENERS.has(cp)) return OP;
+  if (cp === 0x2d || cp === 0x2010 || cp === 0x2013 || cp === 0x2014) return HY;
+  if (
+    (cp >= 0x2e80 && cp <= 0x2fff) ||
+    (cp >= 0x3001 && cp <= 0x303f) ||
+    (cp >= 0x3040 && cp <= 0x30ff) ||
+    (cp >= 0x3100 && cp <= 0x31ff) ||
+    (cp >= 0x3200 && cp <= 0x4dbf) ||
+    (cp >= 0x4e00 && cp <= 0x9fff) ||
+    (cp >= 0xa000 && cp <= 0xa4cf) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe30 && cp <= 0xfe4f) ||
+    (cp >= 0xff00 && cp <= 0xffef) ||
+    (cp >= 0x1f300 && cp <= 0x1faff) ||
+    (cp >= 0x2600 && cp <= 0x27bf) ||
+    (cp >= 0x20000 && cp <= 0x3ffff)
+  )
+    return ID;
+  if ((cp >= 0x0e00 && cp <= 0x0eff) || (cp >= 0x1000 && cp <= 0x109f) || (cp >= 0x1780 && cp <= 0x17ff) || (cp >= 0x1950 && cp <= 0x19df)) return SA;
+  return AL;
+}
+
+/**
+ * Splits a paragraph into unbreakable segments (each followed by its
+ * trailing spaces). Leading spaces of the paragraph are dropped.
+ */
+export function segmentText(text: string, lang: string, mode: 'space' | 'char'): Segmentation {
+  const bounds = graphemeBounds(text, lang);
+  const count = bounds.length - 1;
+  const cls = new Uint8Array(count);
+  let hasSA = false;
+  for (let i = 0; i < count; i++) {
+    cls[i] = breakClass(text.codePointAt(bounds[i]) ?? 0);
+    if (cls[i] === SA) hasSA = true;
+  }
+
+  // Dictionary word boundaries for scripts written without spaces.
+  let wordStarts: Set<number> | null = null;
+  if (mode === 'char' && hasSA) {
+    const seg = segmenter(lang, 'word');
+    if (seg) {
+      wordStarts = new Set();
+      for (const s of seg.segment(text)) wordStarts.add(s.index);
+    }
+  }
+
+  const isLetter = (g: number) => LETTER.test(String.fromCodePoint(text.codePointAt(bounds[g]) ?? 0));
+  const latinLike = (g: number) => cls[g] === AL || ((text.codePointAt(bounds[g]) ?? 0x80) < 0x80 && cls[g] !== WSP);
+  const canBreak = (a: number, b: number): boolean => {
+    const A = cls[a];
+    const B = cls[b];
+    if (A === ZW) return true;
+    if (B === CL || B === ZW) return false;
+    if (A === OP) return false;
+    // "state-of-the-art" may wrap after a hyphen; "1-2" and "-5" may not.
+    if (A === HY) return B === AL && a > 0 && cls[a - 1] === AL && isLetter(b) && isLetter(a - 1);
+    if (A === ID || B === ID) return true;
+    if (mode !== 'char') return false;
+    if (A === SA && B === SA) return wordStarts ? wordStarts.has(bounds[b]) : true;
+    // Latin words, numbers and their ASCII punctuation ("it's", "v2.0") stay whole in CJK text.
+    return !(latinLike(a) && latinLike(b)) && !(A === HY || B === HY);
+  };
+
+  const segments: Segment[] = [];
+  let i = 0;
+  while (i < count && cls[i] === WSP) i++;
+  while (i < count) {
+    const start = bounds[i];
+    let j = i + 1;
+    while (j < count && cls[j] !== WSP && !canBreak(j - 1, j)) j++;
+    const end = bounds[j];
+    let k = j;
+    while (k < count && cls[k] === WSP) k++;
+    segments.push({ start, end, wsEnd: bounds[k] });
+    i = k;
+  }
+  return { graphemes: bounds, segments };
+}

package/vendor/wajha/engine/markup.ts

@@ -0,0 +1,84 @@
+/**
+ * Slide text markup. Users type plain text with three conventions:
+ *   *word*   highlighted run (toggles, so "*a* b *c*" highlights a and c)
+ *   \*       a literal asterisk
+ *   newline  hard line break (CR LF, CR and the Unicode line/paragraph
+ *            separators are treated the same, since CSV imports carry them)
+ * When the number of unescaped asterisks is odd, the last one is literal, so
+ * "5* rating" and "*unfinished" never turn the rest of a text into a highlight.
+ */
+import { engineCache } from './cache';
+
+export interface MarkupRun {
+  readonly text: string;
+  readonly highlighted: boolean;
+}
+
+/** One hard-broken line of text; empty for blank lines. */
+export type MarkupParagraph = readonly MarkupRun[];
+
+const parsed = engineCache<string, readonly MarkupParagraph[]>(256);
+
+/** Parses markup into paragraphs of runs. Adjacent runs never share the same highlight state. */
+export function parseMarkup(text: string): readonly MarkupParagraph[] {
+  const source = typeof text === 'string' ? text : '';
+  const hit = parsed.get(source);
+  if (hit) return hit;
+
+  const src = source.replace(/\r\n?|[\u2028\u2029]/g, '\n');
+  let toggles = 0;
+  for (let i = 0; i < src.length; i++) {
+    if (src[i] === '\\' && src[i + 1] === '*') i++;
+    else if (src[i] === '*') toggles++;
+  }
+  const lastIsLiteral = toggles % 2 === 1;
+
+  const paragraphs: MarkupParagraph[] = [];
+  let runs: MarkupRun[] = [];
+  let buf = '';
+  let highlighted = false;
+  let seen = 0;
+  const flush = () => {
+    if (!buf) return;
+    const last = runs[runs.length - 1];
+    // Empty toggles ("a**b") would otherwise leave two plain runs side by side.
+    if (last && last.highlighted === highlighted) runs[runs.length - 1] = { text: last.text + buf, highlighted };
+    else runs.push({ text: buf, highlighted });
+    buf = '';
+  };
+
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    if (ch === '\\' && src[i + 1] === '*') {
+      buf += '*';
+      i++;
+    } else if (ch === '*') {
+      seen++;
+      if (lastIsLiteral && seen === toggles) {
+        buf += '*';
+      } else {
+        flush();
+        highlighted = !highlighted;
+      }
+    } else if (ch === '\n') {
+      flush();
+      paragraphs.push(Object.freeze(runs.map((r) => Object.freeze(r))));
+      runs = [];
+    } else {
+      buf += ch;
+    }
+  }
+  flush();
+  paragraphs.push(Object.freeze(runs.map((r) => Object.freeze(r))));
+
+  const result = Object.freeze(paragraphs);
+  parsed.set(source, result);
+  return result;
+}
+
+/** The text with markup removed (for character counts, accessibility labels, search). */
+export function plainText(text: string): string {
+  return parseMarkup(text)
+    .map((p) => p.map((r) => r.text).join(''))
+    .join('\n');
+}