/** * Inline syntax the visual engine reads on top of CommonMark and GFM (spec * R-FMT-1, R-INL-1, R-INL-6, R-INL-7): * * - `==highlight==`, as the selection toolbar writes it; * - `<u>underline</u>`, the HTML pair that renders as underline everywhere; * - `[[Page]]` and `[[Page#heading-slug]]` wiki links; * - links to a paper in the project library, which edit as citation chips. * * CommonMark reads the first three as text or inline HTML, so they are found * in the parsed phrasing afterwards, and only where the source spells them * literally: an escaped `\==` or `\[\[` stays text. * * Clean implementation for Lattice; spec: docs/visual-editor-spec.md. */import type { PhrasingContent } from "mdast"; type Position = { start: { offset?: number }; end: { offset?: number } };/** Phrasing as parsed, plus this module's own node kinds. */export type Phrasing = { type: string; value?: string; children?: Phrasing[]; position?: Position; [key: string]: unknown }; const at = (start: number, end: number): Position => ({ start: { offset: start }, end: { offset: end } });const startOf = (node: Phrasing) => node.position?.start.offset;const endOf = (node: Phrasing) => node.position?.end.offset; /** A library paper's reading file, as a citation links it (R-FMT-17, §11.10). */export const PAPER_HREF = /^(?:\.\.\/)*\.research\/papers\/[^/\s]+\/(?:paper|blog)\.md$/; /** * The phrasing of one parent, with highlight, underline and wiki links * recognized. Nested phrasing is extended when the reader reaches it. */export function extendPhrasing(children: PhrasingContent[], source: string): PhrasingContent[] {  let nodes = children as unknown as Phrasing[];  nodes = underlines(nodes);  nodes = wikiLinks(nodes, source);  nodes = highlights(nodes, source);  return nodes as unknown as PhrasingContent[];} /** A text node whose source is exactly its value: no escapes or references to misplace offsets. */function literalText(node: Phrasing, source: string): boolean {  const from = startOf(node);  const to = endOf(node);  return node.type === "text" && from != null && to != null && source.slice(from, to) === node.value;} const textPiece = (value: string, start: number): Phrasing => ({ type: "text", value, position: at(start, start + value.length) }); /** `<u>` … `</u>` among one parent's children becomes an underline around them. */function underlines(nodes: Phrasing[]): Phrasing[] {  const result: Phrasing[] = [];  for (let index = 0; index < nodes.length; index += 1) {    const node = nodes[index]!;    if (node.type === "html" && /^<u>$/i.test(node.value ?? "")) {      const close = nodes.findIndex((candidate, position) => position > index && candidate.type === "html" && /^<\/u>$/i.test(candidate.value ?? ""));      if (close > index + 1) {        const from = startOf(node);        const to = endOf(nodes[close]!);        result.push({ type: "latticeUnderline", children: nodes.slice(index + 1, close), position: from != null && to != null ? at(from, to) : undefined });        index = close;        continue;      }    }    result.push(node);  }  return result;} const WIKI = /\[\[([^[\]\n|]+)\]\]/g; /** `[[Page]]` in literal text becomes a wiki link. */function wikiLinks(nodes: Phrasing[], source: string): Phrasing[] {  const result: Phrasing[] = [];  for (const node of nodes) {    if (!literalText(node, source) || !node.value!.includes("[[")) {      result.push(node);      continue;    }    const value = node.value!;    const base = startOf(node)!;    let cursor = 0;    for (const match of value.matchAll(WIKI)) {      const target = match[1]!.trim();      if (!target) continue;      if (match.index > cursor) result.push(textPiece(value.slice(cursor, match.index), base + cursor));      result.push({ type: "latticeWiki", target, value: match[0], position: at(base + match.index, base + match.index + match[0].length) });      cursor = match.index + match[0].length;    }    if (cursor < value.length) result.push(cursor ? textPiece(value.slice(cursor), base + cursor) : node);  }  return result;} type Token = { node: Phrasing } | { delimiter: number; before: string; after: string }; /** * `==text==` becomes a highlight: an opening `==` followed by a non-space, a * closing one after a non-space, neither part of a longer run of `=`. */function highlights(nodes: Phrasing[], source: string): Phrasing[] {  if (!nodes.some((node) => literalText(node, source) && node.value!.includes("=="))) return nodes;  const tokens: Token[] = [];  nodes.forEach((node, index) => {    if (!literalText(node, source) || !node.value!.includes("==")) {      tokens.push({ node });      return;    }    const value = node.value!;    const base = startOf(node)!;    let cursor = 0;    for (const match of value.matchAll(/=+/g)) {      if (match[0].length !== 2) continue;      if (match.index > cursor) tokens.push({ node: textPiece(value.slice(cursor, match.index), base + cursor) });      const before = match.index > 0 ? value[match.index - 1]! : nodes[index - 1] ? "x" : "";      const afterIndex = match.index + 2;      const after = afterIndex < value.length ? value[afterIndex]! : nodes[index + 1] ? "x" : "";      tokens.push({ delimiter: base + match.index, before, after });      cursor = afterIndex;    }    if (cursor < value.length) tokens.push({ node: textPiece(value.slice(cursor), base + cursor) });  });  const result: Phrasing[] = [];  let opener = -1;  const flush = (upTo: number, from: number) => {    for (let index = from; index < upTo; index += 1) {      const token = tokens[index]!;      result.push("node" in token ? token.node : textPiece("==", token.delimiter));    }  };  let emitted = 0;  tokens.forEach((token, index) => {    if ("node" in token) return;    const opens = token.after !== "" && !/\s/.test(token.after);    const closes = token.before !== "" && !/\s/.test(token.before);    if (opener >= 0 && closes && index > opener + 1) {      flush(opener, emitted);      const open = tokens[opener] as { delimiter: number };      const inner: Phrasing[] = [];      for (let position = opener + 1; position < index; position += 1) {        const item = tokens[position]!;        inner.push("node" in item ? item.node : textPiece("==", item.delimiter));      }      result.push({ type: "latticeHighlight", children: inner, position: at(open.delimiter, token.delimiter + 2) });      emitted = index + 1;      opener = -1;    } else if (opens) {      opener = index;    }  });  flush(tokens.length, emitted);  return mergeText(result);} /** Adjacent text pieces read as one text node, as the parser gives them. */function mergeText(nodes: Phrasing[]): Phrasing[] {  const result: Phrasing[] = [];  for (const node of nodes) {    const previous = result[result.length - 1];    if (previous?.type === "text" && node.type === "text" && endOf(previous) === startOf(node)) {      result[result.length - 1] = { ...previous, value: `${previous.value}${node.value}`, position: at(startOf(previous)!, endOf(node)!) };    } else {      result.push(node);    }  }  return result;}