@heycys/gallery 0.0.0-stage → 0.1.0

package/browser/editor/page/clipboard/import/math.mjs

@@ -0,0 +1,100 @@
+import { parseInlineMath, unescapeMarkdown } from "./inline.mjs";
+
+// Formulas in pasted content, beyond what Notion knows (notion-lite ai-math.js): copied from
+// ChatGPT, Gemini, Claude, DeepSeek, Wikipedia… a formula would be lost or garbled.
+//   convertRenderedMath(root)  formulas a page drew, as Notion's own formula marks (data-notion-
+//     equation / data-notion-inline-equation, which html.mjs reads), before the conversion:
+//     KaTeX (.katex-display display, .katex inline): the TeX in annotation[encoding="application/x-tex"];
+//     [data-math] (Gemini; display with block / display in its class, or a div);
+//     MathJax 2: script[type^="math/tex"] (mode=display: display), the .MathJax* drawn beside it removed;
+//     MathML (Wikipedia): its annotation or alttext, {\displaystyle …} taken off; .mwe-math-element
+//     (with a fallback picture) replaced whole.
+//   mathifySpecs(specs)  formulas still in the text of converted blocks (AI pages and their copy
+//     buttons give the TeX as text): a text block that is only $$ … $$ / \[ … \] / \\[ … \\] a
+//     formula block; $ … $, $$ … $$, \( … \), \\( … \\) in text inline formulas (code and formulas
+//     left alone; table cells too).
+
+const EQ = "data-notion-equation";
+const INLINE_EQ = "data-notion-inline-equation";
+
+function equationElement(doc, tex, display) {
+  const element = doc.createElement(display ? "div" : "span");
+  element.setAttribute(display ? EQ : INLINE_EQ, tex);
+  element.textContent = tex;
+  return element;
+}
+
+const stripDisplaystyle = (tex) => tex.replace(/^\{\\displaystyle\s*([\s\S]*)\}$/, "$1").trim();
+
+export function convertRenderedMath(root) {
+  const doc = root.ownerDocument;
+  for (const element of [...root.querySelectorAll(".katex-display, .katex")]) {
+    if (!element.isConnected) continue;
+    const tex = element.querySelector('annotation[encoding="application/x-tex"]')?.textContent?.trim();
+    if (tex) element.replaceWith(equationElement(doc, tex, element.classList.contains("katex-display")));
+  }
+  for (const element of [...root.querySelectorAll("[data-math]")]) {
+    if (!element.isConnected) continue;
+    const tex = element.getAttribute("data-math")?.trim();
+    if (tex) element.replaceWith(equationElement(doc, tex, /block|display/i.test(element.getAttribute("class") ?? "") || element.tagName === "DIV"));
+  }
+  for (const script of [...root.querySelectorAll('script[type^="math/tex"]')]) {
+    const display = /mode=display/.test(script.getAttribute("type"));
+    for (let p = script.previousElementSibling; p && /MathJax/.test(p.getAttribute("class") ?? ""); p = script.previousElementSibling) p.remove();
+    const tex = script.textContent.trim();
+    if (tex) script.replaceWith(equationElement(doc, tex, display));
+    else script.remove();
+  }
+  for (const math of [...root.querySelectorAll("math")]) {
+    if (!math.isConnected) continue;
+    const tex = math.querySelector('annotation[encoding="application/x-tex"]')?.textContent?.trim() || math.getAttribute("alttext")?.trim();
+    if (!tex) continue;
+    (math.closest(".mwe-math-element") ?? math).replaceWith(equationElement(doc, stripDisplaystyle(tex), math.getAttribute("display") === "block"));
+  }
+}
+
+// Inline formulas in rich text's plain pieces, as formula pieces with the piece's annotations.
+function mathifyTitle(title) {
+  if (!Array.isArray(title)) return title;
+  const out = [];
+  for (const [text, annotations] of title) {
+    if (annotations?.some((a) => a[0] === "c" || a[0] === "e") || !/[$\\]/.test(text)) {
+      out.push(annotations ? [text, annotations] : [text]);
+      continue;
+    }
+    for (const [piece, own] of parseInlineMath(text)) {
+      const merged = [...(own ?? []), ...(annotations ?? [])];
+      out.push(merged.length ? [piece, merged] : [piece]);
+    }
+  }
+  return out;
+}
+
+// A whole text that is a display formula: its TeX, else null. [pattern, escaped inside, its end
+// that may not come again inside].
+const DISPLAY = [[/^\\\\\[([\s\S]+)\\\\\]$/, true, "\\\\]"], [/^\\\[([\s\S]+)\\\]$/, false, "\\]"], [/^\$\$([\s\S]+)\$\$$/, false, "$$"]];
+function displayMathOf(title) {
+  if (!title?.length || title.some(([, a]) => a?.some((x) => x[0] === "c" || x[0] === "e"))) return null;
+  const text = title.map((t) => t[0]).join("").trim();
+  for (const [pattern, escaped, close] of DISPLAY) {
+    const match = pattern.exec(text);
+    if (match && !match[1].includes(close)) return (escaped ? unescapeMarkdown(match[1]) : match[1]).trim();
+  }
+  return null;
+}
+
+export function mathifySpecs(specs) {
+  return specs.map((s) => {
+    if (s.type === "code" || s.type === "equation") return s;
+    if (s.type === "text" && !s.children?.length) {
+      const tex = displayMathOf(s.title);
+      if (tex) return { type: "equation", title: [[tex]], props: {}, children: [] };
+    }
+    const props = { ...s.props };
+    if (props.cells) props.cells = Object.fromEntries(Object.entries(props.cells).map(([key, value]) => [key, mathifyTitle(value)]));
+    if (props.caption) props.caption = mathifyTitle(props.caption);
+    return { ...s, title: mathifyTitle(s.title), props, children: mathifySpecs(s.children ?? []) };
+  });
+}
+
+export const mathifyRichText = mathifyTitle;

package/browser/editor/page/clipboard/import/office.mjs

@@ -0,0 +1,245 @@
+// HTML copied from Word, WPS or OneNote, through TinyMCE's Word paste filter first, as Notion does
+// (393771 → 860274 → 980556 tF; TinyMCE's WordFilter, MIT; notion-lite office-filter.js). Notion
+// uses it only when the HTML has Office's namespaces (read.mjs) and looks like Word's (isWordContent:
+// Mso classes, mso- styles, w:WordDocument, OutlineElement…), with its settings: no retained style
+// properties (bold and italic as b / i, nothing else), the default valid elements, fake lists made
+// lists.
+//   1. Patterns out: Apple's line break marks, Google Docs' guid wrapper, comments (conditional
+//      ones too), scripts, <?xml>, img / meta / link / style tags, namespaced tags (o:p: the tag
+//      alone); <s> → <strike>; &nbsp; → a no-break space; mso-spacerun's spaces halved.
+//   2. Attributes: style — mso-list gives the list level, mso-list:Ignore marks the node and its
+//      first child to go, comments go, mso- is dropped, font-weight / font-style not normal wrap
+//      it in b / i, no other style stays; class — comments' and revisions' elements go, the rest
+//      loses it; del goes; a — comment links go, file:// links keep what follows #, anchors without
+//      href, or named other than a contents / note mark, lose the tag.
+//   3. Only the valid elements and attributes stay: strong(b) em(i) u span p(div) ol ul li h1~h6
+//      a[href|name] sub sup strike br del table[width] tr td/th[colspan|rowspan|width] thead tfoot
+//      tbody; others lose their tag, spans without attributes too, empty ones go.
+//   4. Fake lists: top-level <p> starting with •·§● → ul; with 1. / a. / iv. / 一. … → ol (its
+//      start); with an mso-list level → ul; nested by level, their bullet or number taken off.
+// Besides TinyMCE's (feishu-lite's color matching, colors.mjs): with `colors`, a text color and a
+// background in a style stay as data-paste-color / data-paste-background, which html.mjs maps to
+// the page's colors (Feishu keeps Word's colors; Notion drops them).
+
+const NBSP = String.fromCharCode(0xa0);
+
+/** Whether HTML looks like Word's (Notion's test). */
+export const isWordContent = (html) =>
+  /<font face="Times New Roman"|class="?Mso|style="[^"]*\bmso-|style='[^']*\bmso-|w:WordDocument/i.test(html) || /class="OutlineElement/.test(html) || /id="?docs-internal-guid-/.test(html);
+
+const VALID = {
+  strong: [], em: [], u: [], span: [], p: [], ol: [], ul: [], li: [], h1: [], h2: [], h3: [], h4: [], h5: [], h6: [], a: ["href", "name"],
+  sub: [], sup: [], strike: [], br: [], del: [], table: ["width"], tr: [], td: ["colspan", "rowspan", "width"], th: ["colspan", "rowspan", "width"], thead: [], tfoot: [], tbody: [],
+};
+const COLOR_ATTRIBUTES = ["data-paste-color", "data-paste-background"];
+const ALIAS = { b: "strong", i: "em", div: "p" };
+const REMOVE_EMPTY = new Set(["strong", "em", "u", "span", "p", "ol", "ul", "li", "h1", "h2", "h3", "h4", "h5", "h6", "a"]);
+const BULLET = /^[\s\u00a0]*[\u2022\u00b7\u00a7\u25CF]\s*/;
+const NUMBERED = [/^[IVXLMCD]{1,2}\.[ \u00a0]/, /^[ivxlmcd]{1,2}\.[ \u00a0]/, /^[a-z]{1,2}[.)][ \u00a0]/, /^[A-Z]{1,2}[.)][ \u00a0]/, /^[0-9]+\.[ \u00a0]/,
+  /^[\u3007\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d]+\.[ \u00a0]/, /^[\u58f1\u5f10\u53c2\u56db\u4f0d\u516d\u4e03\u516b\u4e5d\u62fe]+\.[ \u00a0]/];
+
+function regexFilters(html) {
+  const rules = [
+    /<br class="?Apple-interchange-newline"?>/gi,
+    /<b[^>]+id="?docs-internal-[^>]*>/gi,
+    /<!--[\s\S]+?-->/gi,
+    /<(!|script[^>]*>.*?<\/script(?=[>\s])|\/?(\?xml(:\w+)?|img|meta|link|style|\w:\w+)(?=[\s/>]))[^>]*>/gi,
+    [/<(\/?)s>/gi, "<$1strike>"],
+    [/&nbsp;/gi, NBSP],
+    [/<span\s+style\s*=\s*"\s*mso-spacerun\s*:\s*yes\s*;?\s*"\s*>([\s\u00a0]*)<\/span>/gi,
+      (_, spaces) => (spaces.length > 0 ? spaces.replace(/./, " ").slice(Math.floor(spaces.length / 2)).split("").join(NBSP) : "")],
+  ];
+  for (const rule of rules) html = rule instanceof RegExp ? html.replace(rule, "") : html.replace(rule[0], rule[1]);
+  return html;
+}
+
+const parseStyle = (style) => (style ?? "").split(";").map((part) => part.split(":")).filter(([key, value]) => key?.trim() && value !== undefined)
+  .map(([key, ...value]) => [key.trim().toLowerCase(), value.join(":").trim()]);
+
+const tagOf = (element) => element.tagName.toLowerCase();
+function wrapWith(element, tag) {
+  const wrapper = element.ownerDocument.createElement(tag);
+  element.parentNode.insertBefore(wrapper, element);
+  wrapper.appendChild(element);
+}
+const unwrap = (element) => element.replaceWith(...element.childNodes);
+
+/** Word's HTML filtered (TinyMCE's WordFilter as Notion sets it); `colors`: colors kept as data-paste-*. */
+export function filterWordContent(html, { colors = false } = {}) {
+  const doc = new globalThis.DOMParser().parseFromString(regexFilters(html), "text/html");
+  const root = doc.body;
+  const level = new WeakMap();
+  const ignore = new WeakSet();
+  // 2. Attributes (style, class, del, a).
+  for (const element of [...root.querySelectorAll("*")]) {
+    if (!element.isConnected) continue;
+    const style = element.getAttribute("style");
+    if (style !== null) {
+      let removed = false;
+      let bold = false;
+      let italic = false;
+      for (const [name, value] of parseStyle(style)) {
+        if (name === "mso-list") {
+          const match = /\w+ \w+([0-9]+)/i.exec(style);
+          if (match) level.set(element, parseInt(match[1], 10));
+          if (/Ignore/i.test(value) && element.firstChild) {
+            ignore.add(element);
+            ignore.add(element.firstChild);
+          }
+        } else if (name === "font-weight" && value !== "normal") bold = /bold/i.test(value);
+        else if (name === "font-style" && value !== "normal") italic = /italic/i.test(value);
+        else if (name === "mso-element" && /^(comment|comment-list)$/i.test(value)) {
+          removed = true;
+          break;
+        } else if (colors && name === "color") element.setAttribute("data-paste-color", value);
+        else if (colors && (name === "background" || name === "background-color" || name === "mso-highlight")) element.setAttribute("data-paste-background", value);
+        if (name.startsWith("mso-comment")) {
+          removed = true;
+          break;
+        }
+      }
+      if (removed) {
+        element.remove();
+        continue;
+      }
+      element.removeAttribute("style");
+      if (bold) wrapWith(element, "b");
+      if (italic) wrapWith(element, "i");
+      if (tagOf(element) === "span" && element.parentNode && !element.attributes.length) {
+        unwrap(element);
+        continue;
+      }
+    }
+    const className = element.getAttribute("class");
+    if (className !== null) {
+      if (/^(MsoCommentReference|MsoCommentText|msoDel)$/i.test(className)) {
+        element.remove();
+        continue;
+      }
+      element.removeAttribute("class");
+    }
+    if (tagOf(element) === "del") {
+      element.remove();
+      continue;
+    }
+    if (tagOf(element) === "a") {
+      let href = element.getAttribute("href");
+      const name = element.getAttribute("name");
+      if (href && href.includes("#_msocom_")) {
+        element.remove();
+        continue;
+      }
+      if (href && href.startsWith("file://")) {
+        href = href.split("#")[1];
+        if (href) href = `#${href}`;
+      }
+      if ((!href && !name) || (name && !/^_?(?:toc|edn|ftn)/i.test(name))) {
+        unwrap(element);
+        continue;
+      }
+      if (href) element.setAttribute("href", href);
+      else element.removeAttribute("href");
+    }
+  }
+  // 3. The valid elements: renamed, others unwrapped, other attributes dropped, empty ones gone.
+  for (let element of [...root.querySelectorAll("*")].reverse()) {
+    if (!element.isConnected) continue;
+    let tag = tagOf(element);
+    // A div holding blocks (Word's WordSection wrapper of a whole page) goes: TinyMCE's parser takes p in p apart.
+    if (tag === "div" && [...element.children].some((child) => /^(P|DIV|H[1-6]|UL|OL|TABLE)$/.test(child.tagName))) {
+      unwrap(element);
+      continue;
+    }
+    if (ALIAS[tag]) {
+      const next = doc.createElement(ALIAS[tag]);
+      for (const attribute of element.attributes) next.setAttribute(attribute.name, attribute.value);
+      next.append(...element.childNodes);
+      if (level.has(element)) level.set(next, level.get(element));
+      if (ignore.has(element)) ignore.add(next);
+      element.replaceWith(next);
+      element = next;
+      tag = ALIAS[tag];
+    }
+    if (!(tag in VALID)) {
+      unwrap(element);
+      continue;
+    }
+    for (const attribute of [...element.attributes]) {
+      const name = attribute.name.toLowerCase();
+      if (!VALID[tag].includes(name) && !(colors && COLOR_ATTRIBUTES.includes(name))) element.removeAttribute(attribute.name);
+    }
+    if (REMOVE_EMPTY.has(tag) && !element.childNodes.length) element.remove();
+  }
+  // 4. Fake lists made lists.
+  let current = null;
+  let previous = null;
+  let lastLevel = 1;
+  const trimStart = (node, pattern) => {
+    if (node.nodeType === 3) {
+      if (pattern.test(node.data)) {
+        node.data = node.data.replace(pattern, "");
+        return false;
+      }
+    }
+    for (let child = node.firstChild; child; child = child.nextSibling) if (!trimStart(child, pattern)) return false;
+    return true;
+  };
+  const removeIgnored = (node) => {
+    if (ignore.has(node)) {
+      node.remove();
+      return;
+    }
+    for (const child of [...node.childNodes]) removeIgnored(child);
+  };
+  const toItem = (p, listTag, start) => {
+    const itemLevel = level.get(p) || lastLevel;
+    if (itemLevel !== lastLevel) {
+      if (itemLevel < lastLevel) {
+        if (current) current = current.parentNode?.parentNode ?? null;
+      } else {
+        previous = current;
+        current = null;
+      }
+    }
+    const item = doc.createElement("li");
+    if (!current || tagOf(current) !== listTag) {
+      previous = previous || current;
+      current = doc.createElement(listTag);
+      if (start > 1) current.setAttribute("start", String(start));
+      p.parentNode.insertBefore(current, p);
+    }
+    item.append(...p.childNodes);
+    current.appendChild(item);
+    p.remove();
+    if (itemLevel > lastLevel && previous?.lastElementChild) previous.lastElementChild.appendChild(current);
+    lastLevel = itemLevel;
+    level.set(item, itemLevel);
+    removeIgnored(item);
+    trimStart(item, /^\u00a0+/);
+    trimStart(item, /^\s*([\u2022\u00b7\u00a7\u25CF]|\w+\.)/);
+    trimStart(item, /^\u00a0+/);
+  };
+  for (const element of [...root.childNodes]) {
+    if (element.nodeType === 1 && tagOf(element) === "p" && element.firstChild) {
+      const text = element.textContent ?? "";
+      if (BULLET.test(text)) {
+        toItem(element, "ul");
+        continue;
+      }
+      if (NUMBERED.some((pattern) => pattern.test(text.replace(/^[\u00a0 ]+/, "")))) {
+        const match = /([0-9]+)\./.exec(text);
+        toItem(element, "ol", match ? parseInt(match[1], 10) : 1);
+        continue;
+      }
+      if (level.get(element)) {
+        toItem(element, "ul", 1);
+        continue;
+      }
+      current = null;
+    } else {
+      previous = current;
+      current = null;
+    }
+  }
+  return root.innerHTML;
+}

package/browser/editor/page/clipboard/import/read.mjs

@@ -0,0 +1,120 @@
+import { containsRichFormatting, htmlToBlocks, htmlToRichText, parseClipboardHTML } from "./html.mjs";
+import { filterWordContent, isWordContent } from "./office.mjs";
+import { mathifyRichText, mathifySpecs } from "./math.mjs";
+import { fromMarkdown } from "./markdown.mjs";
+import { parseInlineMarkdown } from "./inline.mjs";
+import { vscodeLanguage } from "./languages.mjs";
+import { addressOf } from "../../links/address.mjs";
+
+// What a paste from another program is (Notion 860313 clipboardActions' external content, notion-lite
+// editor/input/clipboard/index.js): the clipboard read in Notion's order, as block specs, one rich
+// text to go in at the caret, or plain text.
+//   - Text: U+2028 as line breaks (text/uri-list when there is no text). HTML only with "rich
+//     formatting" (html.mjs containsRichFormatting; WordPress's always): spans, divs and paragraphs
+//     alone paste as their text.
+//   - Office's HTML (its namespaces) that looks like Word's goes through the Word filter (office.mjs).
+//   - A whole $$ formula $$ → a formula block; several lines from VS Code → code in its language.
+//   - HTML: several lines of text, or a table → blocks (html.mjs htmlToBlocks); else one rich text.
+//   - No HTML: several lines → Markdown (markdown.mjs); one line → inline Markdown (bold, links,
+//     addresses, formulas) when it has any, else plain text. A whole line that is a display formula
+//     (\[ … \]) → a formula block.
+// Besides Notion's: formulas AI answers copy (math.mjs, markdown.mjs, inline.mjs) and colors
+// (feishu-lite: html.mjs `colors`; nearest for Word, Google Docs and Notion, whose styles are meant,
+// as Feishu's 129153 · P; else only the page's own).
+
+const OFFICE = /schemas-microsoft-com:office|xmlns:m="http:\/\/schemas\.microsoft\.com\/office\/2004\/12\/omml"/;
+const WORDPRESS = /<!-- wp:/;
+// 860313 E: a whole $$ formula $$.
+const EQUATION = /^\s*\$\$[ \t]*\r?\n?([\s\S]+?)\r?\n?[ \t]*\$\$\s*$/;
+const multiline = (text) => text.trimEnd().includes("\n"); // 860313 L
+// Clipboard types of sources whose styles are meant (Feishu 129153 · P).
+const STYLED = ["application/x-vnd.google-docs-document-slice-clip+wrapped", "text/_notion-page-source-production", "text/_notion-text-production", "text/_notion-blocks-v3-production"];
+
+/**
+ * The clipboard's other programs' content (860313 ef): { text, html (with rich formatting, else ""),
+ * fromOffice, isTable (its first element a table, before normalizing), language (VS Code's), colors }.
+ */
+export function externalContent(data, { base } = {}) {
+  const text = (data.getData("text/plain") || "").replace(/\u2028/g, "\n").replace(/\r\n?/g, "\n") || data.getData("text/uri-list") || "";
+  const original = data.getData("text/html") || "";
+  const fromOffice = OFFICE.test(original);
+  const types = [...(data.types ?? [])];
+  const colors = fromOffice || types.some((type) => STYLED.includes(type)) ? "nearest" : "exact";
+  const raw = fromOffice && isWordContent(original) ? filterWordContent(original, { colors: true }) : original;
+  let html = "";
+  let isTable = false;
+  if (raw) {
+    const probe = parseClipboardHTML(raw, { base });
+    isTable = probe.firstElementChild?.tagName === "TABLE";
+    if (containsRichFormatting(probe, { colors }) || (WORDPRESS.test(raw) && WORDPRESS.test(text))) html = raw;
+  }
+  let mode = null;
+  try {
+    mode = JSON.parse(data.getData("vscode-editor-data") || "null")?.mode ?? null;
+  } catch {
+    // not JSON
+  }
+  return { text, html, fromOffice, isTable, language: mode ? vscodeLanguage(mode) : null, colors };
+}
+
+/**
+ * The href of what is on the clipboard when that is an address alone, else null. The plain text says
+ * so (addressOf); HTML beside it, as a web page's link has when it is copied, may hold nothing but a
+ * link to that address, or the same words (a code editor's colored text). An address written with
+ * www. says no scheme: the link beside it is that same link under either, and gives its own.
+ */
+export function bareAddress(data, options = {}) {
+  const plain = data.getData("text/plain");
+  const href = addressOf(plain);
+  const html = data.getData("text/html");
+  if (!href || !html) return href;
+  const root = parseClipboardHTML(html, options);
+  const [link, ...others] = root.querySelectorAll("a[href]");
+  if (others.length > 0 || root.querySelector("img, picture, svg, video, audio, table")) return null;
+  const words = (text) => text.replace(/\s+/g, "");
+  if (!link) return words(root.textContent) === words(plain) ? href : null;
+  if (words(root.textContent) !== words(link.textContent)) return null;
+  const unsaid = /^www\./i.test(plain.trim());
+  if (!sameAddress(unsaid ? link.href.replace(/^https:/i, "http:") : link.href, href)) return null;
+  return unsaid ? link.href : href;
+}
+
+function sameAddress(one, other) {
+  try {
+    return new URL(one).href === new URL(other).href;
+  } catch {
+    return one === other;
+  }
+}
+
+/**
+ * Another program's content as { kind: "blocks", specs } | { kind: "rich", title } | { kind: "plain",
+ * text } (notion-lite readClipboard, after the editor's own formats).
+ */
+export function readExternal(data, options = {}) {
+  const external = externalContent(data, options);
+  const { text, html } = external;
+  const convert = { colors: external.colors };
+  const equation = EQUATION.exec(text)?.[1];
+  if (equation?.trim()) return { kind: "blocks", specs: [{ type: "equation", title: [[equation]], props: {}, children: [] }] };
+  if (multiline(text) && external.language) return { kind: "blocks", specs: [{ type: "code", title: [[text]], props: { language: external.language }, children: [] }] };
+  if (html) {
+    if (multiline(text) || external.isTable) {
+      const specs = mathifySpecs(htmlToBlocks(parseClipboardHTML(html, options), convert));
+      if (specs.length) return { kind: "blocks", specs };
+    }
+    const title = mathifyRichText(htmlToRichText(parseClipboardHTML(html, options), convert));
+    return title.length ? { kind: "rich", title } : { kind: "plain", text };
+  }
+  if (multiline(text)) {
+    const specs = fromMarkdown(text);
+    if (specs.length) return { kind: "blocks", specs };
+  }
+  // One line: a whole display formula → a formula block; else inline Markdown (860313 eE → 389867 Z4)
+  // when it makes anything, else plain text (an address alone stays text: the page may link it).
+  const single = fromMarkdown(text);
+  if (single.length === 1 && single[0].type === "equation") return { kind: "blocks", specs: single };
+  const title = parseInlineMarkdown(text);
+  if (title.some((piece) => piece[1]?.length) && !addressOf(text)) return { kind: "rich", title };
+  return { kind: "plain", text };
+}

package/browser/editor/page/clipboard/import/rich.mjs

@@ -0,0 +1,29 @@
+// What the import builds (import/): notion-lite's block specs and rich text, so that its conversions
+// port as they are and their results compare with Notion's own (tests/unit/paste.mjs). to-blocks.mjs
+// turns them into the page's blocks.
+//
+//   spec       { type, title, props, children }: Notion's block types (text, header, sub_header,
+//              sub_sub_header, header_4, bulleted_list, numbered_list, to_do, quote, callout, toggle,
+//              code, equation, divider, table + table_row, image, embed, file, column_list + column,
+//              tab; besides them the kit's flowchart, report_flow + report_step: html.mjs), props as
+//              Notion's (checked, language, source, caption, block_color, icon, …)
+//   rich text  [[text, [[annotation, value?], …]], …] (inline.mjs names the annotations)
+
+export const spec = (type, title = [], props = {}, children = []) => ({ type, title, props, children });
+
+const annotationKey = (annotations) => JSON.stringify([...annotations].map((a) => JSON.stringify(a)).sort());
+
+/** Rich text with neighbouring pieces of the same annotations joined and empty ones dropped. */
+export function normalize(title) {
+  const out = [];
+  for (const [text, annotations] of title ?? []) {
+    if (!text) continue;
+    const last = out.at(-1);
+    if (last && annotationKey(last[1] ?? []) === annotationKey(annotations ?? [])) last[0] += text;
+    else out.push(annotations?.length ? [text, annotations] : [text]);
+  }
+  return out;
+}
+
+/** The plain text of rich text (a formula as its TeX). */
+export const plainOf = (title) => (title ?? []).map(([text, annotations]) => annotations?.find((a) => a[0] === "e")?.[1] ?? text).join("");