@eocrm/design-system 0.6.24 → 0.7.0

package/src/components/RichText/engine/toMarkdown.ts

@@ -1,97 +0,0 @@
-// toMarkdown.ts — serialize a RichDoc to Markdown (CommonMark + GFM strikethrough,
-// restricted to the model). The inverse of fromMarkdown. Lossy: underline has no
-// Markdown syntax and is dropped — use toHtml for full fidelity.
-import type { RichDoc, Block, Inline, MarkType } from './model';
-import { runsText } from './inlines';
-import { safeHref } from './safeHref';
-import { isListItem, effectiveDepths } from './listDepths';
-import { attachmentIsImage } from './attachment';
-
-/** Backslash-escape inline specials so literal chars don't become formatting. */
-function escapeMd(s: string): string {
-  return s.replace(/[\\*_`[\]]/g, (c) => `\\${c}`);
-}
-
-/** Escape a leading block marker at the very start of the content. */
-function escapeLineStart(s: string): string {
-  return s.replace(/^(\s*)([#>+-]|\d+\.)/, '$1\\$2');
-}
-
-// Inline marks innermost → outermost (link applied last, outermost).
-const MARKERS: { type: MarkType; open: string; close: string }[] = [
-  { type: 'code', open: '`', close: '`' },
-  { type: 'strike', open: '~~', close: '~~' },
-  { type: 'italic', open: '*', close: '*' },
-  { type: 'bold', open: '**', close: '**' },
-];
-
-function inlineRun(run: Inline): string {
-  const isCode = run.marks.some((m) => m.type === 'code');
-  // Code content is verbatim; other text is MD-escaped. textColor/bgColor marks
-  // have no Markdown representation and are dropped (like underline) — the run's
-  // text passes through unchanged with no color markup.
-  let text = isCode ? run.text : escapeMd(run.text);
-  for (const m of MARKERS) {
-    if (run.marks.some((mk) => mk.type === m.type)) text = `${m.open}${text}${m.close}`;
-  }
-  const linkMark = run.marks.find((m) => m.type === 'link');
-  if (linkMark && linkMark.type === 'link') text = `[${text}](${safeHref(linkMark.href) ?? ''})`;
-  return text;
-}
-
-function blockMd(block: Block, depth: number): string {
-  if (block.type === 'code_block') return '```\n' + runsText(block.inlines) + '\n```';
-  if (block.type === 'attachment') {
-    // Only finalized attachments serialize; in-flight/failed uploads emit nothing.
-    if (block.status && block.status !== 'ready') return '';
-    // An unsafe src drops the whole block (consistent with toHtml) rather than
-    // emitting an empty-URL link.
-    const url = safeHref(block.src ?? '');
-    if (url === undefined) return '';
-    return attachmentIsImage(block)
-      ? `![${block.alt ?? block.name ?? ''}](${url})`
-      : `[${block.name ?? url}](${url})`;
-  }
-  const inline = escapeLineStart(block.inlines.map(inlineRun).join(''));
-  switch (block.type) {
-    case 'heading':
-      return `${'#'.repeat(block.level ?? 1)} ${inline}`;
-    case 'blockquote':
-      return `> ${inline}`;
-    case 'bullet_item':
-      return `${'  '.repeat(depth)}- ${inline}`;
-    case 'ordered_item':
-      return `${'  '.repeat(depth)}1. ${inline}`;
-    case 'paragraph':
-    default:
-      return inline;
-  }
-}
-
-/**
- * Serialize a `RichDoc` to Markdown (CommonMark + GFM strikethrough), the inverse
- * of `fromMarkdown`. Lossy: **underline and text/background color are dropped** (no
- * Markdown syntax — use `toHtml` for full fidelity) and **mentions degrade to plain
- * `@label` text** (the id is not representable in Markdown — `toHtml`/`fromHtml`
- * preserve mentions); images/tables aren't modeled; MD-special escaping
- * is best-effort.
- *
- * @example
- * const md = toMarkdown(doc); // '# Title\n\n- one\n- two'
- */
-export function toMarkdown(doc: RichDoc): string {
-  const eff = effectiveDepths(doc.blocks);
-  let out = '';
-  for (let i = 0; i < doc.blocks.length; i += 1) {
-    const b = doc.blocks[i];
-    if (i > 0) {
-      // Consecutive SAME-TYPE list items stay in one list (single newline). A
-      // bullet→ordered transition needs a blank line, or the Markdown parser would
-      // read both as one list and coerce the second to the first's type.
-      const prev = doc.blocks[i - 1];
-      out += isListItem(prev) && isListItem(b) && prev.type === b.type ? '\n' : '\n\n';
-    }
-    out += blockMd(b, isListItem(b) ? eff[i] : 0);
-  }
-  return out;
-}

package/src/components/RichText/engine/transforms.ts

@@ -1,434 +0,0 @@
-// transforms.ts — Layer D. Document transforms. Pure + immutable; each returns
-// { doc, selection } (the new doc + where the caret/selection should land).
-import type { RichDoc, Block, Point, Range, Mark, MarkType } from './model';
-import { createBlock, nextId } from './model';
-import { normalizeInlines, sliceInlines, mapMarksOverRange, runsLength } from './inlines';
-import { withMark, withoutMark, hasMark } from './marks';
-import {
-  blockLength,
-  findBlockIndex,
-  orderedRange,
-  isCollapsed,
-  collapsedRange,
-  marksForTypedText,
-} from './position';
-import { isVoidBlock } from './attachment';
-
-function collapsed(point: Point): Range {
-  return collapsedRange(point.blockId, point.offset);
-}
-
-function replaceBlock(doc: RichDoc, index: number, block: Block): RichDoc {
-  const blocks = doc.blocks.slice();
-  blocks[index] = block;
-  return { blocks };
-}
-
-/** Bounds of the mention run strictly containing `offset`, or null. */
-function mentionRunBoundsAt(block: Block, offset: number): { start: number; end: number } | null {
-  let pos = 0;
-  for (const run of block.inlines ?? []) {
-    const s = pos;
-    const e = pos + run.text.length;
-    pos = e;
-    if (offset > s && offset < e && run.marks.some((m) => m.type === 'mention')) {
-      return { start: s, end: e };
-    }
-  }
-  return null;
-}
-
-/** Snap a range START leftward out of any mention it bisects. */
-function snapStartOffset(block: Block, offset: number): number {
-  const b = mentionRunBoundsAt(block, offset);
-  return b ? b.start : offset;
-}
-
-/** Snap a range END rightward out of any mention it bisects. */
-function snapEndOffset(block: Block, offset: number): number {
-  const b = mentionRunBoundsAt(block, offset);
-  return b ? b.end : offset;
-}
-
-/**
- * Pure/immutable. Insert `text` at `point`, inheriting the marks of the character
- * immediately before the cursor (see {@link marksForTypedText} for the `mention`
- * and `link` boundary exceptions). Returns `{ doc, selection }` with the caret
- * placed after the inserted text. On a void block the text opens a new paragraph
- * after the void. No-op (returns input unchanged) when `text` is empty or
- * `point.blockId` does not exist in `doc`.
- */
-export function insertText(
-  doc: RichDoc,
-  point: Point,
-  text: string,
-): { doc: RichDoc; selection: Range } {
-  if (text === '') return { doc, selection: collapsed(point) };
-  const idx = findBlockIndex(doc, point.blockId);
-  if (idx === -1) return { doc, selection: collapsed(point) };
-  const block = doc.blocks[idx];
-  // A void block (e.g. an attachment) holds no editable text — never splice the
-  // typed text into it. The caret sits beside it (e.g. after a doc-final image),
-  // so the text opens a new paragraph AFTER the void, like insertFragment does.
-  // ponytail: a caret BEFORE a void maps to the same {void, 0} point, so it also
-  // lands after; distinguishing would need a second void offset in the model.
-  if (isVoidBlock(block)) {
-    const after = createBlock('paragraph', text);
-    const blocks = [...doc.blocks.slice(0, idx + 1), after, ...doc.blocks.slice(idx + 1)];
-    return { doc: { blocks }, selection: collapsed({ blockId: after.id, offset: text.length }) };
-  }
-  const inlines = normalizeInlines([
-    ...sliceInlines(block.inlines, 0, point.offset),
-    { text, marks: marksForTypedText(doc, point) },
-    ...sliceInlines(block.inlines, point.offset, blockLength(block)),
-  ]);
-  return {
-    doc: replaceBlock(doc, idx, { ...block, inlines }),
-    selection: collapsed({ blockId: block.id, offset: point.offset + text.length }),
-  };
-}
-
-/**
- * Pure/immutable. Delete the content covered by `range`. If `range` is collapsed
- * (anchor === focus) returns `{ doc, selection }` unchanged — no-op. Cross-block
- * ranges merge the surviving text of the start and end blocks. Returns `{ doc,
- * selection }` with the caret at the deletion point.
- */
-export function deleteRange(doc: RichDoc, range: Range): { doc: RichDoc; selection: Range } {
-  const ord = orderedRange(doc, range);
-  let start = ord.start;
-  let end = ord.end;
-  // Collapsed input → no-op (never snap a collapsed caret into a deletion).
-  if (start.blockId === end.blockId && start.offset === end.offset) {
-    return { doc, selection: collapsed(start) };
-  }
-  const si = findBlockIndex(doc, start.blockId);
-  const ei = findBlockIndex(doc, end.blockId);
-  if (si === -1 || ei === -1) return { doc, selection: collapsed(start) };
-  // Snap endpoints out of any mention run they bisect, so a partial selection (or
-  // a one-char backspace/forward-delete at a chip edge) removes the whole chip.
-  start = { ...start, offset: snapStartOffset(doc.blocks[si], start.offset) };
-  end = { ...end, offset: snapEndOffset(doc.blocks[ei], end.offset) };
-  const startBlock = doc.blocks[si];
-  const endBlock = doc.blocks[ei];
-  const startVoid = isVoidBlock(startBlock);
-  const endVoid = isVoidBlock(endBlock);
-  // A void block contributes no text to the merge. Crucially, the survivor must be
-  // a TEXT block — never `{...void, inlines: text}` (a model-illegal "attachment
-  // with text" that also drops the text from render/serialize). When the start is
-  // void, base the survivor on the end block (if it's text) else a fresh paragraph,
-  // but keep the start block's id so the caret target stays valid.
-  const inlines = normalizeInlines([
-    ...(startVoid ? [] : sliceInlines(startBlock.inlines, 0, start.offset)),
-    ...(endVoid ? [] : sliceInlines(endBlock.inlines, end.offset, blockLength(endBlock))),
-  ]);
-  let survivor: Block;
-  if (!startVoid) {
-    survivor = { ...startBlock, inlines };
-  } else if (!endVoid) {
-    survivor = { ...endBlock, id: startBlock.id, inlines };
-  } else {
-    survivor = { ...createBlock('paragraph', '', { id: startBlock.id }), inlines };
-  }
-  const blocks = doc.blocks.slice();
-  blocks.splice(si, ei - si + 1, survivor);
-  return {
-    doc: { blocks },
-    selection: collapsed({ blockId: startBlock.id, offset: startVoid ? 0 : start.offset }),
-  };
-}
-
-/**
- * Pure/immutable. Split the block at `point` into two blocks of the same type,
- * placing the caret at offset 0 of the new (right) block. On a void block it
- * inserts an empty paragraph after the void instead. Returns `{ doc, selection }`.
- * No-op (returns input) when `point.blockId` is not found.
- */
-export function splitBlock(doc: RichDoc, point: Point): { doc: RichDoc; selection: Range } {
-  const idx = findBlockIndex(doc, point.blockId);
-  if (idx === -1) return { doc, selection: collapsed(point) };
-  const block = doc.blocks[idx];
-  if (isVoidBlock(block)) {
-    // Can't split a void — Enter beside it opens an empty paragraph after it.
-    const after = createBlock('paragraph');
-    const blocks = [...doc.blocks.slice(0, idx + 1), after, ...doc.blocks.slice(idx + 1)];
-    return { doc: { blocks }, selection: collapsed({ blockId: after.id, offset: 0 }) };
-  }
-  const left: Block = {
-    ...block,
-    inlines: normalizeInlines(sliceInlines(block.inlines, 0, point.offset)),
-  };
-  const rightInlines = normalizeInlines(
-    sliceInlines(block.inlines, point.offset, blockLength(block)),
-  );
-  const right: Block = {
-    ...createBlock(block.type, '', { level: block.level, depth: block.depth }),
-    inlines: rightInlines,
-  };
-  const blocks = doc.blocks.slice();
-  blocks.splice(idx, 1, left, right);
-  return { doc: { blocks }, selection: collapsed({ blockId: right.id, offset: 0 }) };
-}
-
-/**
- * Pure/immutable. Merge the block identified by `blockId` into the preceding
- * block, appending its inlines. Returns `{ doc, selection }` with the caret at the
- * join point. No-op (returns input) when `blockId` is the first block in the doc.
- */
-export function mergeBlockBackward(
-  doc: RichDoc,
-  blockId: string,
-): { doc: RichDoc; selection: Range } {
-  const idx = findBlockIndex(doc, blockId);
-  if (idx <= 0) return { doc, selection: collapsed({ blockId, offset: 0 }) };
-  const prev = doc.blocks[idx - 1];
-  const cur = doc.blocks[idx];
-  if (isVoidBlock(prev)) {
-    const blocks = doc.blocks.slice();
-    blocks.splice(idx - 1, 1); // drop the preceding void; `cur` shifts up
-    return { doc: { blocks }, selection: collapsed({ blockId: cur.id, offset: 0 }) };
-  }
-  if (isVoidBlock(cur)) {
-    const blocks = doc.blocks.slice();
-    blocks.splice(idx, 1); // drop the void; caret to end of prev
-    return {
-      doc: { blocks },
-      selection: collapsed({ blockId: prev.id, offset: blockLength(prev) }),
-    };
-  }
-  const joinOffset = blockLength(prev);
-  const inlines = normalizeInlines([...prev.inlines, ...cur.inlines]);
-  const blocks = doc.blocks.slice();
-  blocks.splice(idx - 1, 2, { ...prev, inlines });
-  return { doc: { blocks }, selection: collapsed({ blockId: prev.id, offset: joinOffset }) };
-}
-
-function transformMarksOverRange(
-  doc: RichDoc,
-  range: Range,
-  fn: (marks: Mark[]) => Mark[],
-): { doc: RichDoc; selection: Range } {
-  const { start, end } = orderedRange(doc, range);
-  const si = findBlockIndex(doc, start.blockId);
-  const ei = findBlockIndex(doc, end.blockId);
-  if (si === -1 || ei === -1) return { doc, selection: range };
-  const blocks = doc.blocks.slice();
-  for (let i = si; i <= ei; i += 1) {
-    const block = blocks[i];
-    const from = i === si ? start.offset : 0;
-    const to = i === ei ? end.offset : blockLength(block);
-    if (to <= from) continue;
-    blocks[i] = { ...block, inlines: mapMarksOverRange(block.inlines, from, to, fn) };
-  }
-  return { doc: { blocks }, selection: range };
-}
-
-/**
- * Pure/immutable. Apply `mark` to every character in `range`, splitting inline
- * runs at the boundaries as needed. Returns `{ doc, selection }` with the
- * original range preserved.
- */
-export function applyMark(
-  doc: RichDoc,
-  range: Range,
-  mark: Mark,
-): { doc: RichDoc; selection: Range } {
-  return transformMarksOverRange(doc, range, (m) => withMark(m, mark));
-}
-
-/**
- * Pure/immutable. Remove the mark of `type` from every character in `range`.
- * Returns `{ doc, selection }` with the original range preserved.
- */
-export function removeMark(
-  doc: RichDoc,
-  range: Range,
-  type: MarkType,
-): { doc: RichDoc; selection: Range } {
-  return transformMarksOverRange(doc, range, (m) => withoutMark(m, type));
-}
-
-/** True iff every character in the (non-empty) range carries `type`. */
-function rangeHasMarkEverywhere(doc: RichDoc, range: Range, type: MarkType): boolean {
-  const { start, end } = orderedRange(doc, range);
-  if (start.blockId === end.blockId && start.offset === end.offset) return false;
-  const si = findBlockIndex(doc, start.blockId);
-  const ei = findBlockIndex(doc, end.blockId);
-  if (si === -1 || ei === -1) return false;
-  for (let i = si; i <= ei; i += 1) {
-    const block = doc.blocks[i];
-    const from = i === si ? start.offset : 0;
-    const to = i === ei ? end.offset : blockLength(block);
-    if (to <= from) continue;
-    let pos = 0;
-    for (const run of block.inlines) {
-      const rs = pos;
-      const re = pos + run.text.length;
-      pos = re;
-      const f = Math.max(from, rs);
-      const t = Math.min(to, re);
-      if (t > f && !hasMark(run.marks, type)) return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Pure/immutable. If every character in `range` already carries `mark.type`,
- * removes it (via `removeMark`); otherwise applies it (via `applyMark`). Returns
- * `{ doc, selection }` with the original range preserved.
- */
-export function toggleMark(
-  doc: RichDoc,
-  range: Range,
-  mark: Mark,
-): { doc: RichDoc; selection: Range } {
-  return rangeHasMarkEverywhere(doc, range, mark.type)
-    ? removeMark(doc, range, mark.type)
-    : applyMark(doc, range, mark);
-}
-
-/**
- * Pure/immutable. Set (or clear) the single color mark of `type`
- * (`'textColor'` | `'bgColor'`) over `range`. The run carries at most one color
- * mark of each type: a non-null `key` REPLACES any existing one (clear-then-apply);
- * a `null` key CLEARS it. `key` is a palette key (e.g. `'red'`), resolved to a
- * token at render/serialize time — see `colorMarks.ts`. Returns the new `RichDoc`.
- *
- * Note: returns a bare `RichDoc` (not `{ doc, selection }` like the lower-level
- * `applyMark`/`removeMark`) because a color change never moves the caret — callers
- * keep their existing selection.
- */
-export function setColorMark(
-  doc: RichDoc,
-  range: Range,
-  type: 'textColor' | 'bgColor',
-  key: string | null,
-): RichDoc {
-  const cleared = removeMark(doc, range, type).doc;
-  return key ? applyMark(cleared, range, { type, color: key }).doc : cleared;
-}
-
-/**
- * Pure/immutable. Patch the `type`, `level`, and/or `depth` of the block
- * identified by `blockId`. Cleans up irrelevant fields (`level` for non-headings,
- * `depth` for non-list blocks). Returns `{ doc, selection }` with the caret at
- * offset 0 of the block. No-op (returns input) when `blockId` is not found, or
- * when the target is a void block (an attachment can't become a heading/list —
- * converting it would strip the figure rendering and silently lose the file).
- */
-export function setBlockType(
-  doc: RichDoc,
-  blockId: string,
-  patch: Partial<Pick<Block, 'type' | 'level' | 'depth'>>,
-): { doc: RichDoc; selection: Range } {
-  const idx = findBlockIndex(doc, blockId);
-  if (idx === -1) return { doc, selection: collapsed({ blockId, offset: 0 }) };
-  if (isVoidBlock(doc.blocks[idx])) return { doc, selection: collapsed({ blockId, offset: 0 }) };
-  const next: Block = { ...doc.blocks[idx], ...patch };
-  if (next.type !== 'heading') delete next.level;
-  if (next.type !== 'bullet_item' && next.type !== 'ordered_item') delete next.depth;
-  return { doc: replaceBlock(doc, idx, next), selection: collapsed({ blockId, offset: 0 }) };
-}
-
-/**
- * Pure/immutable. Insert a multi-block `fragment` at `range`, replacing any
- * selection, with the conventional paste merge: the fragment's first block
- * continues the current line and its last block rejoins the trailing text.
- * Returns `{ doc, selection }` with the caret at the join. An empty fragment is
- * a no-op (returns the input doc + a collapsed caret).
- */
-export function insertFragment(
-  doc: RichDoc,
-  range: Range,
-  fragment: RichDoc,
-): { doc: RichDoc; selection: Range } {
-  const frag = fragment.blocks;
-  const fragEmpty = frag.length === 0 || (frag.length === 1 && blockLength(frag[0]) === 0);
-
-  const base = isCollapsed(range) ? { doc, selection: range } : deleteRange(doc, range);
-  const caret = base.selection.anchor;
-  if (fragEmpty) return { doc: base.doc, selection: collapsed(caret) };
-
-  const idx = findBlockIndex(base.doc, caret.blockId);
-  if (idx === -1) return { doc: base.doc, selection: collapsed(caret) };
-  const B = base.doc.blocks[idx];
-  // Caret resting on a void block (e.g. paste while the caret sits on an
-  // attachment): never merge the fragment's text INTO the void — splice the
-  // fragment's blocks (fresh ids) immediately after it, caret at the last block.
-  if (isVoidBlock(B)) {
-    const inserted = frag.map((b) => ({ ...b, id: nextId() }));
-    const blocks = base.doc.blocks.slice();
-    blocks.splice(idx + 1, 0, ...inserted);
-    const lastInserted = inserted[inserted.length - 1];
-    return {
-      doc: { blocks },
-      selection: collapsed({ blockId: lastInserted.id, offset: blockLength(lastInserted) }),
-    };
-  }
-  const left = sliceInlines(B.inlines, 0, caret.offset);
-  const right = sliceInlines(B.inlines, caret.offset, blockLength(B));
-
-  if (frag.length === 1) {
-    const merged = normalizeInlines([...left, ...frag[0].inlines, ...right]);
-    const offset = caret.offset + runsLength(frag[0].inlines);
-    return {
-      doc: replaceBlock(base.doc, idx, { ...B, inlines: merged }),
-      selection: collapsed({ blockId: B.id, offset }),
-    };
-  }
-
-  const first = frag[0];
-  const last = frag[frag.length - 1];
-  const middle = frag.slice(1, -1).map((b) => ({ ...b, id: nextId() }));
-  const bleft: Block = { ...B, inlines: normalizeInlines([...left, ...first.inlines]) };
-  const bright: Block = {
-    ...last,
-    id: nextId(),
-    inlines: normalizeInlines([...last.inlines, ...right]),
-  };
-  const blocks = base.doc.blocks.slice();
-  blocks.splice(idx, 1, bleft, ...middle, bright);
-  return {
-    doc: { blocks },
-    selection: collapsed({ blockId: bright.id, offset: runsLength(last.inlines) }),
-  };
-}
-
-/**
- * Pure/immutable. Replace the block-relative span `[range.from, range.to)` with a
- * mention chip run (`text: trigger + mention.label`, mark `{type:'mention', id,
- * label}`) followed by a single trailing space. Returns `{ doc, selection }` with
- * the caret after the trailing space. No-op (collapsed caret at `range.from`) when
- * `blockId` is not found.
- */
-export function insertMention(
-  doc: RichDoc,
-  blockId: string,
-  range: { from: number; to: number },
-  trigger: string,
-  mention: { id: string; label: string },
-): { doc: RichDoc; selection: Range } {
-  const idx = findBlockIndex(doc, blockId);
-  if (idx === -1) return { doc, selection: collapsed({ blockId, offset: range.from }) };
-  // Defense-in-depth: a void block holds no text to replace (no UI path forms a
-  // mention inside one, but keep the engine uniformly void-safe).
-  if (isVoidBlock(doc.blocks[idx]))
-    return { doc, selection: collapsed({ blockId, offset: range.from }) };
-  // Defensive clamp: tolerate an inverted range (from > to). No-op for valid input.
-  const from = Math.min(range.from, range.to);
-  const to = Math.max(range.from, range.to);
-  const block = doc.blocks[idx];
-  const chipText = `${trigger}${mention.label}`;
-  const inlines = normalizeInlines([
-    ...sliceInlines(block.inlines, 0, from),
-    { text: chipText, marks: [{ type: 'mention', id: mention.id, label: mention.label }] },
-    { text: ' ', marks: [] },
-    ...sliceInlines(block.inlines, to, blockLength(block)),
-  ]);
-  const offset = from + chipText.length + 1;
-  return {
-    doc: replaceBlock(doc, idx, { ...block, inlines }),
-    selection: collapsed({ blockId, offset }),
-  };
-}

package/src/components/RichText/imageMaxHeightStyle.ts

@@ -1,10 +0,0 @@
-import type { CSSProperties } from 'react';
-
-/** Inline style carrying `imageMaxHeight` to the image rule; consumer style wins on conflict. */
-export function imageMaxHeightStyle(
-  imageMaxHeight: number | undefined,
-  style: CSSProperties | undefined,
-): CSSProperties | undefined {
-  if (imageMaxHeight === undefined) return style;
-  return { '--rich-text-image-max-height': `${imageMaxHeight}px`, ...style } as CSSProperties;
-}

package/src/components/RichText/index.ts

@@ -1,31 +0,0 @@
-export { RichText } from './RichText';
-export type { RichTextProps } from './RichText';
-// Model types are exported with a `Rich` prefix so the package's flat namespace
-// doesn't claim generic names — `Block`/`Mark`/`Point`/`Inline` are likely future
-// collisions and `Range` shadows the DOM global. The engine keeps the short names
-// internally; only the public surface is prefixed.
-export type {
-  RichDoc,
-  Block as RichBlock,
-  BlockType as RichBlockType,
-  Inline as RichInline,
-  Mark as RichMark,
-  MarkType as RichMarkType,
-  Point as RichPoint,
-  Range as RichRange,
-} from './engine/model';
-export { emptyDoc, createBlock, docFromText } from './engine/model';
-export {
-  insertText,
-  deleteRange,
-  splitBlock,
-  mergeBlockBackward,
-  applyMark,
-  removeMark,
-  toggleMark,
-  setBlockType,
-} from './engine/transforms';
-export { fromHtml } from './engine/fromHtml';
-export { fromMarkdown } from './engine/fromMarkdown';
-export { toHtml } from './engine/toHtml';
-export { toMarkdown } from './engine/toMarkdown';