@heycys/gallery 0.0.0-stage → 0.1.1

package/browser/editor/page/clipboard/own/blocks.mjs

@@ -0,0 +1,211 @@
+import { escapeText } from "../../../../shared/escape.mjs";
+import { heldIn, newContainer, newHost, pastedLines } from "../../core.mjs";
+import { pageBuild } from "../../../components/builders.mjs";
+import { BLOCK_TYPES, COPIED_AS_ITSELF, HOLDS_ONE, TEXT_TYPES, TOGGLES, UNSAID, accepts, clipboardHooks, clipboardOf, isLead, sizeValue } from "../../../components/registry.mjs";
+import { BLOCK_COLORS } from "../../../components/colors.mjs";
+import { MAX_CELL_HTML } from "../../../components/table/index.mjs";
+import { copied, copyOf, reportOf } from "./describe.mjs";
+import { imageSource, kindOfBlock, webPage } from "./rules.mjs";
+
+// Described blocks (describe.mjs and selection.mjs, and import/to-blocks.mjs for other programs' content) made (build),
+// and the clipboard's own data, which is not trusted, checked first (parse, checkBlocks): the
+// structure against accepts(), at most 500 blocks, and every piece of inline HTML goes through
+// pastedLines() again (the format bar's marks only). Another program's content is not checked
+// that way: to-blocks.mjs makes blocks that fit (rules.mjs holds what both go by). What a block must
+// be and how it is made again is its definition's (`clipboard.check`, `build`, with a text block
+// and a filled container the engine's own), and it is written like any other made on the page.
+// Besides the blocks the page makes from its menus: a formula block and a table (their data), and an
+// image or an embed of an address, filled once on the page (PASTED_SOURCE: the clipboard fetches
+// the picture, checks the page).
+
+const COPIES = COPIED_AS_ITSELF; // the cards, a table, a row of columns
+const LIMIT = 500; // blocks in one paste, containers' blocks counted
+/** Where an image or embed pasted keeps its address until the clipboard fills it. */
+export const PASTED_SOURCE = "data-ge-paste-src";
+
+const string = (value, max = 1e6) => typeof value === "string" && value.length <= max;
+// The blocks a description holds, `blocks` or where a definition says (`holds`), each asked whatever
+// the block's type: the clipboard's data is not trusted to say only what its type does.
+const HOLDS = clipboardHooks("holds");
+const heldBy = (block) => [...(block.blocks ?? []), ...HOLDS.flatMap((holds) => holds(block))];
+// A block of a type that wants what `preload` brings, as a description says it.
+const WANTING = Object.keys(BLOCK_TYPES).filter((type) => BLOCK_TYPES[type].preload).map((type) => `"type":"${type}"`);
+
+/**
+ * Described blocks checked, or null when any is not one the page can make where it stands (`box`:
+ * the kind of box they go in, null for the top).
+ */
+export function checkBlocks(blocks) {
+  let count = 0;
+  const valid = (block, box = null) => {
+    if (!block || typeof block !== "object" || ++count > LIMIT) return false;
+    const { type } = block;
+    const clip = clipboardOf(type);
+    if (box && !accepts(box, kindOfBlock(block)) && clip.pastedIn !== box) return false;
+    if (block.color !== undefined && (typeof block.color !== "string" || !block.color.split(" ").every((name) => BLOCK_COLORS.includes(name)))) return false;
+    if (TEXT_TYPES.has(type)) return string(block.html);
+    if (type === "copy") return COPIES.has(block.kind) && Number.isInteger(block.unit) && [block.report, block.text, block.html].every((value) => typeof value === "string")
+      && (block.data === undefined || (Boolean(clipboardOf(block.data?.type).data) && valid(block.data)));
+    return Boolean(clip.check?.(block, {
+      box, string, valid, isLead, imageSource, webPage, sizeValue,
+      // The blocks of a container, as the box it is takes them; `direction`, the test of a direction, where it may fix one.
+      container: (held, direction) => Array.isArray(held.blocks) && (held.direction === undefined || Boolean(direction?.(held.direction))) && held.blocks.every((inner) => valid(inner, BLOCK_TYPES[type].box)),
+    }));
+  };
+  return Array.isArray(blocks) && blocks.length > 0 && blocks.every((block) => valid(block)) ? blocks : null;
+}
+
+/**
+ * The first copy among described blocks, in boxes too, that cannot be made on `doc`: its unit is not
+ * on the page (another report's, or gone since) and it carries no data to make a new one of, or null.
+ * With no `doc` (null: a cut takes them off the page) a copy is made only of its data.
+ */
+export function unmadeCopy(doc, blocks) {
+  for (const block of blocks) {
+    // A copy made of its data is made of what that holds too (an instance's slots: a card in one).
+    const found = block.type === "copy" ? ((doc && copied(doc, block)) ? null : block.data ? unmadeCopy(doc, heldBy(block.data)) : block) : unmadeCopy(doc, heldBy(block));
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Described blocks from the clipboard's own data (its MIME type): checked, or null when it is not such data. */
+export function parse(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  return value?.v === 1 ? checkBlocks(value.blocks) : null;
+}
+
+/**
+ * Cells copied from a table of the page (components/table CELLS_MIME: { v: 1, cells }) as rows of
+ * their inline HTML, or null when it is no such data.
+ */
+export function parseCells(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  const rows = value?.v === 1 && Array.isArray(value.cells) ? value.cells : null;
+  return rows?.length > 0 && rows.every((row) => Array.isArray(row) && row.length > 0 && row.every((cell) => string(cell, MAX_CELL_HTML))) ? rows : null;
+}
+
+/**
+ * Text copied in one block from the clipboard's own data (its inline HTML: selection.mjs
+ * selectedHtml), or null when it holds none. Not trusted either: pastedLines() makes of it the format
+ * bar's marks alone, as of any inline HTML.
+ */
+export function parseText(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  return value?.v === 1 && string(value.html) ? value.html : null;
+}
+
+/**
+ * Inline HTML as nodes of the format bar's marks only, its lines with <br> between them; formulas
+ * of other pages made the page's own by `formula(tex)` where given, links shown with their icon by
+ * `mention(parts)` (pastedLines).
+ */
+function inline(doc, html, { formula = null, mention = null } = {}) {
+  return pastedLines(doc, html, { formula, mention }).flatMap((line, index) => (index > 0 ? [doc.createElement("br"), ...line] : line));
+}
+
+
+// A block's colors (`color`: their classes, one of each family), those its kind takes (TOGGLES).
+function colored(element, block) {
+  for (const name of block.color?.split(" ") ?? []) if (TOGGLES[element.getAttribute("data-ge-unit-kind")]?.includes(name)) element.classList.add(name);
+  return element;
+}
+
+/**
+ * A new block of the page from a described one (checked). `formula(tex)`: an inline formula chip of
+ * the page (none: their TeX as text); `mention(parts)`: a link shown with its icon (none: a link of
+ * its title). What each type adds is its definition's: `clipboard.build`, or the `build` of its
+ * page.mjs (builders.mjs); a container is filled with its blocks, a text type with its inline HTML.
+ */
+export function build(doc, block, options = {}) {
+  if (block.type === "copy") {
+    // copied() found its unit: a copy of it, written by the commit as one (core.mjs nodeOf).
+    const unit = copied(doc, block);
+    if (unit) {
+      const copy = copyOf(unit, { editable: true });
+      copy.setAttribute("data-ge-new", "");
+      copy.setAttribute("data-ge-type", "copy");
+      copy.setAttribute("data-ge-copy", String(block.unit));
+      copy.setAttribute("data-ge-unit-kind", block.kind);
+      return copy;
+    }
+    // Elsewhere: a new one of its data (pasteBlocks checked it has some), the key a chart reads a
+    // table by kept within the report it was copied from (chart-keys.mjs), no other report's.
+    const data = { ...block.data };
+    if (block.report !== reportOf(doc)) delete data.chart;
+    return build(doc, data, options);
+  }
+  const what = {
+    doc,
+    block,
+    host: (type = block.type) => newHost(doc, type),
+    box: (type = block.type) => newContainer(doc, type),
+    inline: (html) => inline(doc, html, options),
+    inner: (blocks) => blocks.map((each) => build(doc, each, options)),
+    one: (each) => build(doc, each, options),
+    colored: (element) => colored(element, block),
+    pending(figure, src) {
+      figure.setAttribute(PASTED_SOURCE, src);
+      return figure;
+    },
+  };
+  const made = clipboardOf(block.type).build ?? pageBuild(block.type);
+  if (made) return made(what);
+  const { box, leaf } = BLOCK_TYPES[block.type] ?? {};
+  const element = box ? what.box() : what.host();
+  element.append(...(box ? what.inner(block.blocks) : what.inline(block.html)));
+  // A box that always holds a block (holdsOne: a highlight block, a callout) described with none (one
+  // the file has empty, copied or cut) holds an empty block of its `leaf` (a paragraph, as a new one
+  // made from "/" holds), after its lead (a highlight block's icon), as one a change empties does
+  // (core.mjs tidyEmptied) and a disclosure's content made again (details/page.mjs): a block to write
+  // in, and one the commit writes, where a box of no blocks is written by none (core.mjs nodeOf) and
+  // was gone at the next reload.
+  if (leaf && HOLDS_ONE.has(box) && heldIn(element).length === 0) element.append(what.host(leaf));
+  return what.colored(element);
+}
+
+// What a block copied as itself says where it carries no data (a card, a row of columns): the words
+// of its markup on one line, UNSAID left out; no line when it says nothing.
+function wordsOf({ html }) {
+  const template = globalThis.document.createElement("template");
+  template.innerHTML = html;
+  for (const node of template.content.querySelectorAll(UNSAID)) node.remove();
+  const words = template.content.textContent.replace(/\s+/g, " ").trim();
+  return words ? [escapeText(words)] : [];
+}
+
+/**
+ * The text of described blocks as inline HTML of the format bar's marks, one `<p>` for each line of
+ * it (a block's text, an item's, a table's cell, a line of code, a tab's name, what a block copied
+ * as itself says), for a place that cannot split (a table's cell, a title): pastedLines() reads it
+ * as it reads any inline HTML.
+ */
+export function joinedHtml(blocks) {
+  const lines = (list) => list.flatMap((block) => {
+    if (block.type === "copy") return block.data ? lines([block.data]) : wordsOf(block);
+    const text = clipboardOf(block.type).text;
+    return text ? text(block, lines) : block.blocks ? lines(block.blocks) : [block.html];
+  });
+  return lines(blocks).map((line) => `<p>${line}</p>`).join("");
+}
+
+/** Whether described blocks hold formulas (inline ones, or a block that wants what `preload` brings), which want KaTeX on the page. */
+export function holdsFormulas(blocks) {
+  const json = JSON.stringify(blocks);
+  return json.includes("doc-math-inline") || WANTING.some((type) => json.includes(type));
+}

package/browser/editor/page/clipboard/own/chart-keys.mjs

@@ -0,0 +1,58 @@
+import { CHART_DATA, CHART_SOURCE, nextChartKey } from "../../../../shared/table-chart.mjs";
+import { COPY_KEYS } from "../../../components/figure/index.mjs";
+
+// The keys of charts drawn from tables in what a paste made (docs/editor.md, "Copying blocks"): a
+// chart drawn from a table names the table by a key (src/shared/table-chart.mjs), and what a paste
+// makes of a card or a table carries its original's: a copy of it (data-ge-type="copy"), or a table
+// made anew of its data (components/table tableData `chart`: one cut, one whose original is gone or
+// changed since the copy). The rules, by key:
+//   - a card and a table pasted together are a pair of their own: both take a new key, the first of
+//     t1, t2 … the page does not hold, so that two pairs never cross;
+//   - a table pasted without its card keeps its key while no table on the page carries it (a cut
+//     table put back, one whose original was deleted: the card draws it again); otherwise it is a
+//     table alone, its key taken off (a chart draws the first table of its key, which could be it);
+//   - a card pasted alone keeps its key: it draws the same table as its original, both drawing it.
+// A copy's new keys ride on it (COPY_KEYS) to the server, which writes them into the copy's source
+// (core.mjs nodeOf: { copy, keys }; source/text.mjs copiedSource); a table made anew is written with
+// its own. The commit makes sure of both against the file as it is then (source/chart-keys.mjs) and
+// says what it changed (page/commit.mjs).
+
+// What carries a key in `root` and in what its templates hold.
+const carriers = (root) => [
+  ...(root.matches?.(`[${CHART_DATA}], [${CHART_SOURCE}]`) ? [root] : []),
+  ...root.querySelectorAll(`[${CHART_DATA}], [${CHART_SOURCE}]`),
+  ...[...root.querySelectorAll("template")].flatMap((template) => carriers(template.content)),
+];
+const keysOf = (node) => [node.getAttribute(CHART_DATA), node.getAttribute(CHART_SOURCE)].filter((key) => key !== null);
+
+/** The blocks a paste made (`made`, not on the page yet), the keys of their cards and tables made their own. */
+export function relinkCopies(doc, made) {
+  const inMade = made.flatMap(carriers);
+  const hosts = inMade.filter((node) => node.hasAttribute(CHART_DATA));
+  const frames = inMade.filter((node) => node.hasAttribute(CHART_SOURCE));
+  if (frames.length === 0) return;
+  const onPage = carriers(doc);
+  const taken = new Set([...onPage, ...inMade].flatMap(keysOf));
+  const renamed = new Map(); // a key -> its new value, null: taken off a table
+  for (const key of new Set(frames.map((frame) => frame.getAttribute(CHART_SOURCE)))) {
+    if (hosts.some((host) => host.getAttribute(CHART_DATA) === key)) {
+      const next = nextChartKey(taken);
+      taken.add(next);
+      renamed.set(key, next);
+    } else if (onPage.some((node) => node.getAttribute(CHART_SOURCE) === key)) renamed.set(key, null);
+  }
+  const sent = new Map(); // a copy -> its keys { old: new | null }
+  for (const [name, nodes] of [[CHART_DATA, hosts], [CHART_SOURCE, frames]]) {
+    for (const node of nodes) {
+      const key = node.getAttribute(name);
+      if (!renamed.has(key)) continue;
+      const next = renamed.get(key);
+      if (next === null && name === CHART_DATA) continue; // a card keeps the key of a table pasted alone
+      if (next === null) node.removeAttribute(name);
+      else node.setAttribute(name, next);
+      const copy = node.closest('[data-ge-type="copy"]');
+      if (copy) (sent.get(copy) ?? sent.set(copy, {}).get(copy))[key] = next;
+    }
+  }
+  for (const [copy, keys] of sent) copy.setAttribute(COPY_KEYS, JSON.stringify(keys));
+}

package/browser/editor/page/clipboard/own/describe.mjs

@@ -0,0 +1,124 @@
+import { isHost, nestedBlocks, serializeInner, unitsOf } from "../../core.mjs";
+import { BLOCK_TYPES, COPIED_AS_ITSELF, COPY_KEEPS, TEXT_TYPES, askClipboard, clipboardOf, sizeValue, unitClipboard } from "../../../components/registry.mjs";
+import { BLOCK_COLORS } from "../../../components/colors.mjs";
+import { containerType, typeOf } from "../../convert.mjs";
+import { pageOfType, pageOfUnit } from "../../page-objects.mjs";
+import { referencedIds } from "../../../../shared/copy-ids.mjs";
+
+// Selected blocks as the clipboard's own description (docs/editor.md, "Copying blocks"): each
+// block's type and inline HTML, its color, and what lists, quotes, panels, disclosures, sections and
+// tabs areas hold (notion-lite copies any block). Blocks the page can make are copied as what they
+// are, each block saying what it carries (`clipboard.describe` of the unit it is: there is no record
+// to copy as notion-lite's, a block being an element), a text block its text and color, a list or a
+// quote what it holds. A card (a chart card, an image, a file, a bookmark, an embed), a table or a
+// row of columns is copied as itself (a "copy" of its unit; a row's cards and tables can only be
+// copied with it): the page shows a copy of the one on
+// the page (what the kit drew taken off, so that it draws again) and the file gets a copy of the
+// block's own source, its ids taken out (source/commit.mjs, { copy }), within the page it was copied
+// from (the clipboard names the report and the block). Elsewhere a table pastes as a new one from its
+// cells (`data`). A report's own widget is bound to the report's script or its ids, and is the
+// Agent's to copy.
+
+export const MIME = "application/x-gallery-blocks";
+// Its name before the product's rename (2026-10-26): a copy writes the same data under it too, so
+// that a page of the old version still open in another tab pastes it as blocks, and a paste reads it
+// when the new one is not there (a copy made on such a page).
+export const OLD_MIME = "application/x-report-studio-blocks";
+/** The clipboard's own data in `data` (a DataTransfer): under MIME, else under OLD_MIME; "" when neither. */
+export const ownData = (data) => data.getData(MIME) || data.getData(OLD_MIME);
+const COPIES = COPIED_AS_ITSELF; // the cards, a table, a row of columns
+export const reportOf = (doc) => doc.querySelector(".doc-page")?.dataset.docId ?? null;
+
+// The editor marks: data-ge-*, and data-rs-*, their name before 2026-10-28, which a file may keep.
+const EDITOR_MARK = /^data-(?:ge|rs)-/;
+
+/**
+ * A copy of a card or a table on the page, as the kit would start it anew: its
+ * drawing, the kit's marks, the editor's marks, its block id and ids taken out. `editable`: its
+ * fields stay editable (a copy pasted on the page, whose fields the commit takes in as text blocks),
+ * its tables keep their tools (COPY_KEEPS: the file gets the same source) and the ids it names itself (an
+ * SVG's markers: src/shared/copy-ids.mjs) stay, to be given a prefix of its own (ids.mjs prefixCopies);
+ * `named`: those ids alone stay, a copy's markup to be made anew somewhere else.
+ */
+export function copyOf(element, { editable = false, named: keepsNamed = editable } = {}) {
+  const clone = element.cloneNode(true);
+  clone.querySelectorAll("[data-doc-dev]").forEach((node) => node.remove());
+  globalThis.DocKit?.dehydrate(clone);
+  const all = [clone, ...clone.querySelectorAll("*")];
+  const named = keepsNamed ? referencedIds(all.flatMap((node) => [...node.attributes])) : new Set();
+  for (const node of all) {
+    const marks = [...node.attributes].filter(({ name, value }) => (EDITOR_MARK.test(name) && !(editable && COPY_KEEPS.has(name))) || name === "data-block-id" || (name === "id" && !named.has(value)));
+    if (!editable && marks.some(({ name }) => EDITOR_MARK.test(name))) node.removeAttribute("contenteditable");
+    marks.forEach(({ name }) => node.removeAttribute(name));
+  }
+  return clone;
+}
+
+/**
+ * The unit on the page a described copy is of, or null when it is gone (or of another page). One whose
+ * description carries its markup (`data.html`: an instance of a package) is that unit only while the
+ * unit holds that markup: what its component wrote may differ where its words do not (a row marked
+ * done), and the file's copy of the unit would hold the file's, not what was copied.
+ */
+export function copied(doc, block) {
+  if (block.report !== reportOf(doc)) return null;
+  const unit = doc.querySelector(`main [data-ge-unit="${block.unit}"]`);
+  if (!unit || unit.getAttribute("data-ge-unit-kind") !== block.kind) return null;
+  // One whose unit's copy cannot stand for it (`copiesAsItself`: an instance with slots) is made of
+  // what it carries, here too: that copy would hold blocks the file writes whole, with ids no answer
+  // of a commit gives the page (source/apply.mjs restoredText names the block alone).
+  if (pageOfUnit(unit)?.copiesAsItself?.(unit) === false) return null;
+  const copy = copyOf(unit);
+  return (typeof block.data?.html === "string" ? copy.outerHTML === block.html : copy.textContent === block.text) ? unit : null;
+}
+
+/** A block's colors (their classes, space-separated), or null. */
+export const colorOf = (node) => BLOCK_COLORS.filter((name) => node.classList.contains(name)).join(" ") || null;
+
+/** The type a text block is copied as: its own, the type of the text blocks of what wraps it (a quote's paragraph), or null (code, whose text is no text block's). */
+export function copiedType(host) {
+  const type = typeOf(host);
+  const own = BLOCK_TYPES[type]?.wraps ? BLOCK_TYPES[type].leaf : type;
+  return TEXT_TYPES.has(own) ? own : null;
+}
+
+// An element's words on one line.
+const plain = (node) => (node?.textContent ?? "").replace(/\s+/g, " ").trim();
+
+/** What copies of a block the page could make: { type, html, text, blocks, lists }, or null. */
+export function describe(node) {
+  const kind = node.getAttribute("data-ge-unit-kind");
+  // What an element holds: its units. One that is no box has none (a list of a class of its own:
+  // source/units.mjs boxKind), and what stands in it is read as it stands.
+  const holding = (box) => {
+    if (!box) return null;
+    const units = unitsOf(box);
+    const blocks = (units.length > 0 || box.hasAttribute("data-ge-box") ? units : [...box.children]).map(describe);
+    return blocks.every(Boolean) ? blocks : null;
+  };
+  // Copied as itself. One whose unit's copy cannot stand for it (`copiesAsItself` of its page object:
+  // an instance with slots, whose blocks that copy would write whole) is copied by what it carries
+  // alone (`data`, those blocks described apart), and is no copy where it carries nothing (a block in a
+  // slot the page cannot make).
+  if (COPIES.has(kind)) {
+    if (!node.hasAttribute("data-ge-unit") || node.hasAttribute("data-ge-new")) return null; // not in the file yet
+    const copy = copyOf(node);
+    const data = unitClipboard(node).data?.(node, { serializeInner, copyOf, clipboardOf, copiedType, page: pageOfType, holding });
+    if (!data && pageOfUnit(node)?.copiesAsItself?.(node) === false) return null;
+    return { type: "copy", kind, unit: Number(node.getAttribute("data-ge-unit")), report: reportOf(node.ownerDocument), text: copy.textContent, html: copy.outerHTML, ...(data ? { data } : {}) };
+  }
+  const what = { page: pageOfType, holding, describe, copiedType, isHost, nestedBlocks, serializeInner, plain, colorOf, sizeValue };
+  const block = askClipboard("describe", node, what);
+  if (block !== undefined) return block;
+  // A text block, of any type: as what it is (a quote's paragraph a paragraph), with its color; a
+  // block of code is none.
+  if (isHost(node)) {
+    const type = copiedType(node);
+    const color = colorOf(node);
+    return type ? { type, html: serializeInner(node), ...(color ? { color } : {}) } : null;
+  }
+  // A list or a quote, as the blocks it holds.
+  const type = containerType(node);
+  const blocks = type ? holding(node) : null;
+  return blocks ? { type, blocks } : null;
+}

package/browser/editor/page/clipboard/own/export.mjs

@@ -0,0 +1,167 @@
+import { clipboardOf } from "../../../components/registry.mjs";
+import { isMention, shownWords } from "../../core.mjs";
+import { COLORS } from "../../../../shared/colors.mjs";
+import { ZWSP } from "../../../../shared/inline-spacing.mjs";
+import { addressOn, decoded, elsewhere, fromFile, fullAddress, pageAddress } from "../../../../shared/page-address.mjs";
+import { heldList } from "../../links/pages.mjs";
+import { groupItems } from "./rules.mjs";
+import { WRITERS, heldToWords } from "./writers.mjs";
+
+// Copied blocks for other programs (notion-lite serialize.js, after Notion 210528 / 389867: the
+// Markdown its export writes, and HTML that reads as the same), each block by the writer of its kind
+// (writers.mjs). Pasted back here without the clipboard's own data, both read as the same blocks
+// (import/), but for a callout: its Markdown a highlight block, its HTML a group of its blocks.
+//   text/plain  Markdown: # … #### headings, "- " / "1. " / "- [ ] " items (an item's lists 4 spaces
+//               in), "> " quotes, <aside> callouts (a highlight block and a callout: its emoji, a highlight
+//               block's, and the text of its first block, its other blocks),
+//               ``` code (its language), $$ formula blocks (an empty one: none), | tables |, ---, a disclosure as an item
+//               holding its blocks, a tabs area as each tab's name and blocks (a row of columns, copied
+//               as itself, as its text); **bold** *italic* ~~strike~~ `code` $formula$, links as their text
+//               (Notion's plain text); a list's items one line apart, other blocks an empty line; a
+//               line that would read as a tag or a fence escaped (writers.mjs heldToWords).
+//   text/html   plain markup: p, a div of a highlight block's or a callout's blocks, h1–h4, ul / ol / li ("[x] " / "[ ] " before a to-do's text), blockquote,
+//               details, pre > code.language-x, hr, table, a formula block as $$ … $$ (an empty one:
+//               nothing, as in Markdown) and an inline one
+//               as $ … $ (Notion's export), colors as the kit's classes with their color in a style.
+// List items copied on their own (each carrying its list's kind) are items of a list of that kind in
+// both. Text selected in one block (textFormats) is its inline HTML for other programs, and as plain
+// text its words alone (notion-lite's inlinePlain: no list's marker, no Markdown).
+
+// The kit's light colors (a background on words its words' fill), for programs without its styles (src/shared/colors.mjs).
+const INK = Object.fromEntries(COLORS.flatMap(({ name, text, mark }) => [[`doc-text-${name}`, `color:${text[0]}`], [`doc-highlight-${name}`, `background-color:${mark[0]}`]]));
+const FORMULA = /^\s*\\\(([\s\S]*)\\\)\s*$/;
+
+// Inline HTML (the format bar's marks: serializeInner's) as nodes to walk, a link shown with its icon
+// by the words the page shows for it (the file's chip holds what they were when it was made).
+function nodesOf(html) {
+  const template = globalThis.document.createElement("template");
+  template.innerHTML = html ?? "";
+  for (const chip of template.content.querySelectorAll("a[href]")) {
+    const words = isMention(chip) && chip.lastChild?.nodeType === 3 ? shownWords(globalThis.document, chip.getAttribute("href")) : null;
+    if (words) chip.lastChild.data = words;
+  }
+  return template.content;
+}
+
+// Inline HTML as Markdown (links as their text alone).
+function markdown(html) {
+  const walk = (node) => [...node.childNodes].map((child) => {
+    if (child.nodeType === 3) return child.data.replace(/\u00a0/g, " ");
+    if (child.nodeType !== 1) return "";
+    if (child.matches(".doc-math-inline")) {
+      const tex = FORMULA.exec(child.textContent)?.[1];
+      return tex !== undefined ? `$${tex.trim()}$` : child.textContent;
+    }
+    const inner = walk(child);
+    if (!inner.trim() && child.localName !== "br") return inner;
+    switch (child.localName) {
+      case "br": return "\n";
+      case "ul": case "ol": // a table cell's list: its items one to a line
+        return `\n${[...child.children].map((item, index) => `${child.localName === "ol" ? `${index + 1}. ` : "- "}${walk(item).trim()}`).join("\n")}\n`;
+      case "strong": return `**${inner}**`;
+      case "em": return `*${inner}*`;
+      case "s": return `~~${inner}~~`;
+      case "code": return `\`${inner}\``;
+      default: return inner;
+    }
+  }).join("");
+  return heldToWords(walk(nodesOf(html)));
+}
+
+// The address that opens a link's document, or a block of this page, from another program, on this
+// server, by the page's link as the list held has it (links/pages.mjs), or null: an address on another
+// server the list does not hold may be another program's, which stays as it is written.
+export function wholeAddress(href) {
+  const here = pageAddress(globalThis.location?.href);
+  if (!here) return null;
+  const { origin } = globalThis.location;
+  const { named } = heldList();
+  const address = fromFile(href, here.slug, origin);
+  if (href.startsWith("#")) {
+    const block = decoded(href.slice(1));
+    return block && globalThis.document.querySelector(`[data-block-id="${CSS.escape(block)}"]`) ? fullAddress(origin, { slug: here.slug, block }, named) : null;
+  }
+  const place = addressOn(address, named, origin) ?? (elsewhere(address, origin) ? null : pageAddress(address));
+  return place ? fullAddress(origin, place, named) : null;
+}
+
+// Inline HTML for other programs: formulas as $ … $, colors with their style, a link shown with its
+// icon as a link of its title (its icon a file of the report's folder, nowhere else), a link to a
+// document or a block by its whole address.
+function portable(html) {
+  const root = nodesOf(html);
+  for (const link of root.querySelectorAll("a[href]")) {
+    const address = wholeAddress(link.getAttribute("href"));
+    if (address) link.setAttribute("href", address);
+  }
+  for (const chip of root.querySelectorAll("a.doc-link-mention")) {
+    chip.querySelector(".doc-link-mention-icon")?.remove();
+    chip.removeAttribute("class");
+  }
+  for (const chip of root.querySelectorAll(".doc-math-inline")) {
+    const tex = FORMULA.exec(chip.textContent)?.[1];
+    if (tex !== undefined) chip.replaceWith(`$${tex.trim()}$`);
+  }
+  for (const span of root.querySelectorAll("span[class]")) {
+    const style = [...span.classList].map((name) => INK[name]).filter(Boolean).join(";");
+    if (style) span.setAttribute("style", style);
+  }
+  const holder = globalThis.document.createElement("div");
+  holder.append(root);
+  return holder.innerHTML;
+}
+
+const isList = (block) => WRITERS[clipboardOf(block.type).kind].list;
+
+function mdLines(blocks) {
+  const lines = [];
+  blocks.forEach((block, index) => {
+    if (WRITERS[clipboardOf(block.type).kind].silent?.(block)) return;
+    if (index > 0 && !(isList(block) && isList(blocks[index - 1]))) lines.push("");
+    lines.push(...mdBlock(block));
+  });
+  return lines;
+}
+
+function mdBlock(block) {
+  if (block.type === "copy") return block.data ? mdBlock(block.data) : [block.text.replace(/\s+/g, " ").trim()]; // a table as its data
+  const clip = clipboardOf(block.type);
+  return WRITERS[clip.kind].copied(block, how, clip);
+}
+
+function htmlBlock(block) {
+  if (block.type === "copy") return block.data ? htmlBlock(block.data) : block.html; // a card: its kit markup
+  const clip = clipboardOf(block.type);
+  return WRITERS[clip.html ?? clip.kind].html(block, how, clip);
+}
+
+// What the writers call back (writers.mjs).
+const how = { inline: markdown, portable, block: mdBlock, lines: mdLines, html: htmlBlock };
+
+/** The clipboard's text/html and text/plain for described blocks. */
+export function formats(blocks) {
+  const listed = groupItems(blocks);
+  return { html: listed.map(htmlBlock).join(""), text: mdLines(listed).join("\n") };
+}
+
+/**
+ * Inline HTML (the format bar's marks, chips as their source) as plain text: a formula as its TeX,
+ * a link and a link shown with its icon as their words, a line break and a table cell's list item a
+ * line of their own (notion-lite inlinePlain).
+ */
+export function plainText(html) {
+  const walk = (node) => [...node.childNodes].map((child) => {
+    if (child.nodeType === 3) return child.data.replace(/ /g, " ").replaceAll(ZWSP, "");
+    if (child.nodeType !== 1) return "";
+    if (child.matches(".doc-math-inline")) return FORMULA.exec(child.textContent)?.[1].trim() ?? child.textContent;
+    if (child.localName === "br") return "\n";
+    if (child.localName === "ul" || child.localName === "ol") return `\n${[...child.children].map((item) => walk(item).trim()).join("\n")}\n`;
+    return walk(child);
+  }).join("");
+  return walk(nodesOf(html)).replace(/^\n+|\n+$/g, "");
+}
+
+/** The clipboard's text/html and text/plain for text selected in one block (its inline HTML). */
+export function textFormats(html) {
+  return { html: portable(html), text: plainText(html) };
+}

package/browser/editor/page/clipboard/own/ids.mjs

@@ -0,0 +1,39 @@
+import { freshPrefix, rewrite } from "../../../../shared/copy-ids.mjs";
+
+// The ids of what a paste made (docs/editor.md, "Copying blocks"): a copy of a card, an instance of a
+// component package or a row of columns holding one keeps the ids it names itself (copyOf: an SVG's
+// marker named by url(#id), a symbol by href="#id", a field by a label's `for`,
+// src/shared/copy-ids.mjs), which the original holds too; each copy gives its own a prefix no id of
+// the page starts with (c1-, c2- …), every reference in it written to match, so that its arrows and
+// gradients draw from its own markers, its label is its own field's and an id still names one element. The
+// server does the same in the file (source/text.mjs copiedSource), from the ids the file holds: the
+// two prefixes may differ, each unique where it stands, and nothing the page sends later carries the
+// copy's ids (a commit takes a copy's text blocks, never its drawing).
+
+/** The copies among `made` (a paste's blocks, not on the page yet, and the copies inside them) given ids of their own. */
+export function prefixCopies(doc, made) {
+  const copy = '[data-ge-type="copy"], [data-ge-copy]';
+  ownIds(doc, made.flatMap((node) => [node, ...node.querySelectorAll(copy)]).filter((node) => node.matches(copy)));
+}
+
+/** `copies`, not on the page yet, given ids of their own. */
+export function ownIds(doc, copies) {
+  if (!copies.some((copy) => copy.querySelector("[id]") || copy.id)) return;
+  const taken = new Set([...doc.querySelectorAll("[id]")].map((node) => node.id));
+  for (const copy of copies) {
+    const owned = [copy, ...copy.querySelectorAll("*")];
+    const ids = owned.filter((node) => node.id).map((node) => node.id);
+    if (ids.length === 0) continue;
+    const prefix = freshPrefix(taken);
+    const renamed = new Map(ids.map((id) => [id, `${prefix}${id}`]));
+    for (const node of owned) {
+      if (node.id) node.id = renamed.get(node.id);
+      for (const attribute of [...node.attributes]) {
+        if (attribute.name === "data-ge-copy") continue; // what the file is written from: its ids are the file's to give
+        const next = rewrite(attribute.name, attribute.value, renamed);
+        if (next !== null) attribute.value = next; // xlink:href in its namespace still
+      }
+    }
+    for (const id of renamed.values()) taken.add(id);
+  }
+}

package/browser/editor/page/clipboard/own/index.mjs

@@ -0,0 +1,13 @@
+// The clipboard's own format (application/x-gallery-blocks, written and read as the old
+// application/x-report-studio-blocks too): selected blocks described
+// (describe.mjs), selected text described (selection.mjs: in one block its inline HTML, across blocks
+// blocks), checked and made again (blocks.mjs), the keys of charts drawn from tables among the copies
+// made their own (chart-keys.mjs), as are the ids a copy's drawing names itself (ids.mjs), and written for other programs
+// (export.mjs, by the table of writers the page export uses too: writers.mjs).
+export { MIME, OLD_MIME, copied, copyOf, describe, ownData, reportOf } from "./describe.mjs";
+export { describeAcross, ownRange, selectedHtml } from "./selection.mjs";
+export { PASTED_SOURCE, build, checkBlocks, holdsFormulas, joinedHtml, parse, parseCells, parseText, unmadeCopy } from "./blocks.mjs";
+export { relinkCopies } from "./chart-keys.mjs";
+export { prefixCopies } from "./ids.mjs";
+export { groupItems, kindOfBlock } from "./rules.mjs";
+export { formats, plainText, textFormats } from "./export.mjs";