@ai-matrx/rich-editor 0.0.0 → 0.1.1

package/dist/core/paste-markdown.js

@@ -0,0 +1,70 @@
+import { Extension } from "@tiptap/core";
+import { Fragment, Slice } from "@tiptap/pm/model";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { buildVisualDocument } from "./visual-document.js";
+import { mergedCellsNotice, normalizePastedHtml } from "./paste-html.js";
+const IDENTITY_ATTRS = ["b", "mdId"];
+function stripIdentity(node) {
+  const attrs = node.attrs ? { ...node.attrs } : void 0;
+  if (attrs) {
+    for (const key of IDENTITY_ATTRS) if (key in attrs) attrs[key] = null;
+  }
+  return {
+    ...node,
+    ...attrs ? { attrs } : {},
+    ...node.content ? { content: node.content.map(stripIdentity) } : {}
+  };
+}
+function markdownToSlice(text, schema) {
+  const normalized = text.replace(/\r\n?/g, "\n");
+  const { json } = buildVisualDocument(normalized, schema);
+  const doc = schema.nodeFromJSON(stripIdentity(json));
+  const blocks = [];
+  doc.forEach((node) => {
+    if (node.type.name === "sourceBlock") node.forEach((child) => blocks.push(child));
+    else blocks.push(node);
+  });
+  if (blocks.length === 0) return Slice.empty;
+  const first = blocks[0];
+  const last = blocks[blocks.length - 1];
+  const openStart = first.type.name === "paragraph" ? 1 : 0;
+  const openEnd = last.type.name === "paragraph" ? 1 : 0;
+  return new Slice(Fragment.from(blocks), openStart, openEnd);
+}
+function replaceSelectionWithMarkdown(tr, schema, text) {
+  const slice = markdownToSlice(text, schema);
+  if (slice.size === 0) tr.deleteSelection();
+  else tr.replaceSelection(slice);
+}
+const MarkdownTextPaste = Extension.create({
+  name: "richEditorMarkdownTextPaste",
+  addOptions() {
+    return { onNotice: null };
+  },
+  addProseMirrorPlugins() {
+    const schema = this.editor.schema;
+    const onNotice = this.options.onNotice;
+    return [
+      new Plugin({
+        key: new PluginKey("richEditorMarkdownTextPaste"),
+        props: {
+          clipboardTextParser: (text) => markdownToSlice(text, schema),
+          // Real-world tables (Wikipedia, Docs, Word, Sheets, Notion) squared and
+          // their cells flattened BEFORE the schema parses them — a second block
+          // in a cell must never become a second cell (paste-html.ts).
+          transformPastedHTML: (html) => {
+            const result = normalizePastedHtml(html);
+            const notice = mergedCellsNotice(result.mergedCellsSplit);
+            if (notice) onNotice?.(notice);
+            return result.html;
+          }
+        }
+      })
+    ];
+  }
+});
+export {
+  MarkdownTextPaste,
+  markdownToSlice,
+  replaceSelectionWithMarkdown
+};

package/dist/core/placeholders.d.ts

@@ -0,0 +1,22 @@
+import type { SourceBlock, SourceIsland } from "@ai-matrx/content-ir/source";
+/** True when the text holds a character from the range placeholders use. */
+export declare function hasPrivateUseCharacter(text: string): boolean;
+export interface PlaceholderText {
+    /** The block text with every inline island replaced by its placeholder. */
+    text: string;
+    /** Islands by placeholder index. */
+    islands: readonly SourceIsland[];
+}
+/** Swap every inline island of a prose block for its placeholder. */
+export declare function withPlaceholders(block: SourceBlock): PlaceholderText;
+/** Put every placeholder in `text` back to its island's exact bytes. */
+export declare function restorePlaceholders(text: string, islands: readonly SourceIsland[]): string;
+export type PlaceholderPiece = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "island";
+    island: SourceIsland;
+};
+/** Split text into literal runs and the islands its placeholders name. */
+export declare function splitPlaceholders(text: string, islands: readonly SourceIsland[]): PlaceholderPiece[];

package/dist/core/placeholders.js

@@ -0,0 +1,60 @@
+const PH_OPEN = "\uE000";
+const DIGIT_BASE = 57600;
+const DIGIT_RANGE = 61439 - DIGIT_BASE + 1;
+const PLACEHOLDER_RE = /([-])([-])/g;
+function hasPrivateUseCharacter(text) {
+  return /[-]/.test(text);
+}
+function encodeIndex(index) {
+  const hi = Math.floor(index / DIGIT_RANGE);
+  const lo = index % DIGIT_RANGE;
+  if (hi >= DIGIT_RANGE) {
+    throw new Error(`too many inline islands in one block (${index})`);
+  }
+  return PH_OPEN + String.fromCharCode(DIGIT_BASE + hi) + String.fromCharCode(DIGIT_BASE + lo);
+}
+function decodeIndex(hi, lo) {
+  return (hi.charCodeAt(0) - DIGIT_BASE) * DIGIT_RANGE + (lo.charCodeAt(0) - DIGIT_BASE);
+}
+function withPlaceholders(block) {
+  if (block.inlines.length === 0) return { text: block.raw, islands: [] };
+  let out = "";
+  let cursor = block.start;
+  block.inlines.forEach((island, index) => {
+    out += block.raw.slice(cursor - block.start, island.start - block.start);
+    out += encodeIndex(index);
+    cursor = island.end;
+  });
+  out += block.raw.slice(cursor - block.start);
+  return { text: out, islands: block.inlines };
+}
+function restorePlaceholders(text, islands) {
+  if (islands.length === 0) return text;
+  return text.replace(PLACEHOLDER_RE, (whole, hi, lo) => {
+    const island = islands[decodeIndex(hi, lo)];
+    return island ? island.raw : whole;
+  });
+}
+function splitPlaceholders(text, islands) {
+  if (islands.length === 0 || !text.includes(PH_OPEN)) {
+    return text ? [{ kind: "text", text }] : [];
+  }
+  const pieces = [];
+  let last = 0;
+  for (const match of text.matchAll(PLACEHOLDER_RE)) {
+    const at = match.index ?? 0;
+    const island = islands[decodeIndex(match[1] ?? "", match[2] ?? "")];
+    if (!island) continue;
+    if (at > last) pieces.push({ kind: "text", text: text.slice(last, at) });
+    pieces.push({ kind: "island", island });
+    last = at + match[0].length;
+  }
+  if (last < text.length) pieces.push({ kind: "text", text: text.slice(last) });
+  return pieces;
+}
+export {
+  hasPrivateUseCharacter,
+  restorePlaceholders,
+  splitPlaceholders,
+  withPlaceholders
+};

package/dist/core/save-plan.d.ts

@@ -0,0 +1,47 @@
+import { type MapOptions, type MappedPosition, type SourceChange, type SpliceIntegrity } from "@ai-matrx/content-ir/source";
+export interface SaveRegion {
+    /** Range in the stored text (block-aligned). */
+    readonly start: number;
+    readonly end: number;
+    /** The replacement from the new text. */
+    readonly text: string;
+}
+export type IslandDeltaKind = "removed" | "changed" | "swallowed" | "moved" | "added";
+export interface IslandDelta {
+    readonly kind: IslandDeltaKind;
+    readonly islandType: string;
+    /** The stored bytes (absent for "added"). */
+    readonly before: string | null;
+    /** The new bytes (absent for "removed"/"swallowed"). */
+    readonly after: string | null;
+    /** Offset of the stored island (or of the region, for "added"). */
+    readonly at: number;
+}
+export interface SavePlan {
+    readonly stored: string;
+    readonly text: string;
+    readonly changed: boolean;
+    readonly regions: readonly SaveRegion[];
+    /** Island changes in edited regions (see header). */
+    readonly islandDeltas: readonly IslandDelta[];
+    /** Removed / changed / swallowed islands the person did not approve. */
+    readonly needsConsent: readonly IslandDelta[];
+    /**
+     * The change sets of the save's splice steps, in order (island step, then
+     * prose step). Carry an anchor through with `mapSavePosition`.
+     */
+    readonly changeSteps: ReadonlyArray<readonly SourceChange[]>;
+    readonly integrity: SpliceIntegrity | null;
+    /** Why the save could not be proven; the person may still save (validation offers, never blocks). */
+    readonly error: string | null;
+}
+export interface PlanSaveOptions {
+    /**
+     * Stored island bytes the person explicitly edited or removed through an
+     * island's own editor — those changes need no second question.
+     */
+    readonly approvedIslands?: ReadonlySet<string>;
+}
+/** Carry a stored-text position through a save (every step, in order). */
+export declare function mapSavePosition(plan: SavePlan, pos: number, options?: MapOptions): MappedPosition;
+export declare function planSave(stored: string, current: string, options?: PlanSaveOptions): SavePlan;

package/dist/core/save-plan.js

@@ -0,0 +1,287 @@
+import {
+  islandEdit,
+  listIslands,
+  mapPosition,
+  spliceSave,
+  tokenizeSource,
+  SourceSpliceError
+} from "@ai-matrx/content-ir/source";
+import { findTableEnd, tableStartsAt } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/gfm-table-lines";
+const MAX_LCS_CELLS = 4e6;
+function blockKey(block) {
+  return `${block.kind}\0${block.islandType ?? ""}\0${block.raw}`;
+}
+function matchBlocks(a, b) {
+  const pairs = [];
+  let lo = 0;
+  while (lo < a.length && lo < b.length && a[lo] === b[lo]) {
+    pairs.push([lo, lo]);
+    lo += 1;
+  }
+  let hiA = a.length - 1;
+  let hiB = b.length - 1;
+  const tail = [];
+  while (hiA >= lo && hiB >= lo && a[hiA] === b[hiB]) {
+    tail.push([hiA, hiB]);
+    hiA -= 1;
+    hiB -= 1;
+  }
+  const n = hiA - lo + 1;
+  const m = hiB - lo + 1;
+  if (n > 0 && m > 0 && n * m <= MAX_LCS_CELLS) {
+    const width = m + 1;
+    const table = new Uint32Array((n + 1) * width);
+    for (let i2 = n - 1; i2 >= 0; i2 -= 1) {
+      for (let j2 = m - 1; j2 >= 0; j2 -= 1) {
+        table[i2 * width + j2] = a[lo + i2] === b[lo + j2] ? (table[(i2 + 1) * width + j2 + 1] ?? 0) + 1 : Math.max(table[(i2 + 1) * width + j2] ?? 0, table[i2 * width + j2 + 1] ?? 0);
+      }
+    }
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+      if (a[lo + i] === b[lo + j]) {
+        pairs.push([lo + i, lo + j]);
+        i += 1;
+        j += 1;
+      } else if ((table[(i + 1) * width + j] ?? 0) >= (table[i * width + j + 1] ?? 0)) {
+        i += 1;
+      } else {
+        j += 1;
+      }
+    }
+  }
+  return pairs.concat(tail.reverse());
+}
+function islandKey(island) {
+  return `${island.islandType}\0${island.raw}`;
+}
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let from = 0;
+  for (; ; ) {
+    const at = haystack.indexOf(needle, from);
+    if (at === -1) return count;
+    count += 1;
+    from = at + needle.length;
+  }
+}
+function islandDeltas(regions) {
+  const gone = [];
+  const added = [];
+  regions.forEach((region, index) => {
+    const remaining = /* @__PURE__ */ new Map();
+    for (const island of region.after) {
+      const list = remaining.get(islandKey(island));
+      if (list) list.push(island);
+      else remaining.set(islandKey(island), [island]);
+    }
+    for (const island of region.before) {
+      const list = remaining.get(islandKey(island));
+      if (list && list.length) list.shift();
+      else gone.push({ island, region: index });
+    }
+    for (const list of remaining.values()) {
+      for (const island of list) added.push({ island, region: index });
+    }
+  });
+  const deltas = [];
+  const unmatchedGone = [];
+  for (const entry of gone) {
+    const at = added.findIndex((candidate) => islandKey(candidate.island) === islandKey(entry.island));
+    if (at === -1) {
+      unmatchedGone.push(entry);
+      continue;
+    }
+    const [arrival] = added.splice(at, 1);
+    deltas.push({
+      kind: "moved",
+      islandType: entry.island.islandType,
+      before: entry.island.raw,
+      after: arrival?.island.raw ?? entry.island.raw,
+      at: entry.island.start
+    });
+  }
+  const swallowedBudget = /* @__PURE__ */ new Map();
+  for (const { island, region } of unmatchedGone) {
+    const info = regions[region];
+    const key = `${region}\0${islandKey(island)}`;
+    if (!swallowedBudget.has(key) && info) {
+      const asIslands = info.after.filter((other) => islandKey(other) === islandKey(island)).length;
+      swallowedBudget.set(key, Math.max(0, countOccurrences(info.afterText, island.raw) - asIslands));
+    }
+    const budget = swallowedBudget.get(key) ?? 0;
+    if (budget > 0) {
+      swallowedBudget.set(key, budget - 1);
+      deltas.push({ kind: "swallowed", islandType: island.islandType, before: island.raw, after: null, at: island.start });
+      continue;
+    }
+    const replacement = added.findIndex(
+      (candidate) => candidate.region === region && candidate.island.islandType === island.islandType
+    );
+    if (replacement !== -1) {
+      const [next] = added.splice(replacement, 1);
+      deltas.push({
+        kind: "changed",
+        islandType: island.islandType,
+        before: island.raw,
+        after: next?.island.raw ?? null,
+        at: island.start
+      });
+    } else {
+      deltas.push({ kind: "removed", islandType: island.islandType, before: island.raw, after: null, at: island.start });
+    }
+  }
+  for (const { island, region } of added) {
+    deltas.push({
+      kind: "added",
+      islandType: island.islandType,
+      before: null,
+      after: island.raw,
+      at: regions[region]?.regionStart ?? 0
+    });
+  }
+  return deltas;
+}
+function spliceInSteps(stored, current, deltas) {
+  const steps = [];
+  const islandEdits = deltas.filter((delta) => delta.kind !== "added" && delta.before !== null).map(
+    (delta) => islandEdit(
+      { start: delta.at, end: delta.at + (delta.before ?? "").length },
+      delta.kind === "changed" ? delta.after ?? "" : ""
+    )
+  ).sort((x, y) => x.start - y.start);
+  let text = stored;
+  if (islandEdits.length) {
+    const result = spliceSave(stored, islandEdits);
+    steps.push({ text: result.text, changes: result.changes, integrity: result.integrity });
+    text = result.text;
+  }
+  if (text !== current) {
+    const plan = regionsBetween(text, current);
+    const result = spliceSave(
+      text,
+      plan.regions.map((region) => ({ start: region.start, end: region.end, text: region.text })),
+      { blocks: plan.storedBlocks }
+    );
+    steps.push({ text: result.text, changes: result.changes, integrity: result.integrity });
+  }
+  return steps;
+}
+function tableRanges(text) {
+  const lines = text.split("\n");
+  const starts = [];
+  let offset = 0;
+  for (const line of lines) {
+    starts.push(offset);
+    offset += line.length + 1;
+  }
+  const ranges = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!tableStartsAt(lines, i)) continue;
+    const end = findTableEnd(lines, i);
+    ranges.push([starts[i] ?? 0, (starts[end - 1] ?? 0) + (lines[end - 1] ?? "").length]);
+    i = end - 1;
+  }
+  return ranges;
+}
+const BR_TAG = /^<br\s*\/?>$/i;
+function isCellLineBreak(delta, stored) {
+  if (delta.kind === "swallowed" || delta.before === null || !BR_TAG.test(delta.before)) return false;
+  if (delta.after !== null && !BR_TAG.test(delta.after)) return false;
+  return tableRanges(stored).some(([start, end]) => delta.at >= start && delta.at < end);
+}
+function regionsBetween(stored, current) {
+  const storedBlocks = tokenizeSource(stored);
+  const currentBlocks = tokenizeSource(current);
+  const a = storedBlocks.filter((block) => block.kind !== "gap");
+  const b = currentBlocks.filter((block) => block.kind !== "gap");
+  const anchors = matchBlocks(a.map(blockKey), b.map(blockKey));
+  const storedIslands = listIslands(storedBlocks);
+  const currentIslands = listIslands(currentBlocks);
+  const within = (islands, start, end) => islands.filter((island) => island.start >= start && island.end <= end);
+  const bounds = [];
+  let prevStored = 0;
+  let prevCurrent = 0;
+  for (const [ai, bi] of anchors) {
+    const sa = a[ai];
+    const sb = b[bi];
+    if (!sa || !sb) continue;
+    bounds.push([prevStored, sa.start, prevCurrent, sb.start]);
+    prevStored = sa.end;
+    prevCurrent = sb.end;
+  }
+  bounds.push([prevStored, stored.length, prevCurrent, current.length]);
+  const regions = [];
+  const regionIslands = [];
+  for (const [sStart, sEnd, cStart, cEnd] of bounds) {
+    const before = stored.slice(sStart, sEnd);
+    const after = current.slice(cStart, cEnd);
+    if (before === after) continue;
+    regions.push({ start: sStart, end: sEnd, text: after });
+    regionIslands.push({
+      before: within(storedIslands, sStart, sEnd),
+      after: within(currentIslands, cStart, cEnd),
+      afterText: after,
+      regionStart: sStart
+    });
+  }
+  return { storedBlocks, regions, regionIslands };
+}
+function mapSavePosition(plan, pos, options) {
+  let mapped = { pos, deleted: false };
+  for (const step of plan.changeSteps) {
+    const next = mapPosition(step, mapped.pos, options);
+    mapped = { pos: next.pos, deleted: mapped.deleted || next.deleted };
+  }
+  return mapped;
+}
+function planSave(stored, current, options = {}) {
+  const unchanged = {
+    stored,
+    text: stored,
+    changed: false,
+    regions: [],
+    islandDeltas: [],
+    needsConsent: [],
+    changeSteps: [],
+    integrity: { ok: true, bytesOutsideEditsIdentical: true, disturbed: [] },
+    error: null
+  };
+  if (stored === current) return unchanged;
+  const { regions, regionIslands } = regionsBetween(stored, current);
+  const deltas = islandDeltas(regionIslands);
+  const approved = options.approvedIslands ?? /* @__PURE__ */ new Set();
+  const needsConsent = deltas.filter(
+    (delta) => delta.kind !== "added" && delta.kind !== "moved" && !(delta.kind !== "swallowed" && delta.before !== null && approved.has(delta.before)) && // The splice still carries it as an island edit (proven); it just never asks.
+    !isCellLineBreak(delta, stored)
+  );
+  let error = null;
+  let changeSteps = [];
+  let integrity = null;
+  try {
+    const steps = spliceInSteps(stored, current, deltas);
+    changeSteps = steps.map((step) => step.changes);
+    integrity = steps[steps.length - 1]?.integrity ?? null;
+    if ((steps[steps.length - 1]?.text ?? stored) !== current) {
+      error = "The save could not be proven: splicing the edited blocks into the stored text did not reproduce what is on screen.";
+    }
+  } catch (caught) {
+    error = caught instanceof SourceSpliceError && caught.code === "integrity" ? "This edit would change protected content outside the part you edited (for example, an unclosed code block or tag swallowing what follows)." : caught instanceof SourceSpliceError && caught.code === "island_edit" ? `A protected block changed in a way the editor could not account for (${caught.message}).` : `The save could not be proven (${caught instanceof Error ? caught.message : String(caught)}).`;
+  }
+  return {
+    stored,
+    text: current,
+    changed: true,
+    regions,
+    islandDeltas: deltas,
+    needsConsent,
+    changeSteps,
+    integrity,
+    error
+  };
+}
+export {
+  mapSavePosition,
+  planSave
+};

package/dist/core/shortcuts.d.ts

@@ -0,0 +1,13 @@
+export type ShortcutGroup = "Text" | "Blocks" | "Insert" | "Document" | "Views";
+export interface ShortcutSpec {
+    id: string;
+    label: string;
+    keys: readonly string[];
+    group: ShortcutGroup;
+    reference: string;
+}
+export declare const RICH_EDITOR_SHORTCUTS: readonly ShortcutSpec[];
+/** Keys that are typed characters, not chords (handled by input rules/menus). */
+export declare const TYPED_TRIGGERS: Set<string>;
+/** Human-readable key label for the platform. */
+export declare function formatKeys(keys: string, apple: boolean): string;

package/dist/core/shortcuts.js

@@ -0,0 +1,50 @@
+const RICH_EDITOR_SHORTCUTS = [
+  { id: "bold", label: "Bold", keys: ["Mod-b"], group: "Text", reference: "Docs \xB7 Notion" },
+  { id: "italic", label: "Italic", keys: ["Mod-i"], group: "Text", reference: "Docs \xB7 Notion" },
+  { id: "strike", label: "Strikethrough", keys: ["Mod-Shift-x", "Mod-Shift-s", "Alt-Shift-5"], group: "Text", reference: "Docs \xB7 Notion" },
+  { id: "code", label: "Inline code", keys: ["Mod-e"], group: "Text", reference: "Notion" },
+  { id: "link", label: "Add or edit link", keys: ["Mod-k"], group: "Text", reference: "Docs \xB7 Notion" },
+  { id: "paragraph", label: "Normal text", keys: ["Mod-Alt-0", "Mod-Shift-0"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "heading1", label: "Heading 1", keys: ["Mod-Alt-1", "Mod-Shift-1"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "heading2", label: "Heading 2", keys: ["Mod-Alt-2", "Mod-Shift-2"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "heading3", label: "Heading 3", keys: ["Mod-Alt-3", "Mod-Shift-3"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "heading4", label: "Heading 4", keys: ["Mod-Alt-4"], group: "Blocks", reference: "Docs" },
+  { id: "heading5", label: "Heading 5", keys: ["Mod-Alt-5"], group: "Blocks", reference: "Docs" },
+  { id: "heading6", label: "Heading 6", keys: ["Mod-Alt-6"], group: "Blocks", reference: "Docs" },
+  { id: "orderedList", label: "Numbered list", keys: ["Mod-Shift-7"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "bulletList", label: "Bulleted list", keys: ["Mod-Shift-8"], group: "Blocks", reference: "Docs \xB7 Notion" },
+  { id: "taskList", label: "Checklist", keys: ["Mod-Shift-9"], group: "Blocks", reference: "Docs" },
+  { id: "quote", label: "Quote", keys: ["Mod-Shift-."], group: "Blocks", reference: "AI Matrx" },
+  { id: "moveUp", label: "Move block up", keys: ["Mod-Shift-ArrowUp"], group: "Blocks", reference: "Notion" },
+  { id: "moveDown", label: "Move block down", keys: ["Mod-Shift-ArrowDown"], group: "Blocks", reference: "Notion" },
+  { id: "codeBlock", label: "Code block", keys: ["Mod-Alt-c"], group: "Insert", reference: "Notion" },
+  { id: "inlineMath", label: "Inline equation", keys: ["Mod-Shift-m"], group: "Insert", reference: "Notion (\u2318\u21E7E)" },
+  { id: "slash", label: "Insert anything", keys: ["/"], group: "Insert", reference: "Notion" },
+  { id: "variable", label: "Insert a variable", keys: ["{{"], group: "Insert", reference: "AI Matrx" },
+  { id: "undo", label: "Undo", keys: ["Mod-z"], group: "Document", reference: "Docs \xB7 Notion" },
+  { id: "redo", label: "Redo", keys: ["Mod-Shift-z", "Mod-y"], group: "Document", reference: "Docs \xB7 Notion" },
+  { id: "find", label: "Find", keys: ["Mod-f"], group: "Document", reference: "Docs" },
+  { id: "replace", label: "Find and replace", keys: ["Mod-h", "Mod-Shift-h"], group: "Document", reference: "Docs" },
+  { id: "save", label: "Save", keys: ["Mod-s", "Mod-Enter"], group: "Document", reference: "Docs \xB7 Notion \xB7 Slack" },
+  { id: "wordCount", label: "Word count", keys: ["Mod-Shift-c"], group: "Document", reference: "Docs" },
+  { id: "outline", label: "Show outline", keys: ["Mod-Alt-h"], group: "Views", reference: "Docs" },
+  { id: "focus", label: "Focus mode", keys: ["Mod-Shift-f"], group: "Views", reference: "iA Writer \xB7 Docs" },
+  { id: "cycleView", label: "Visual \u2192 Source \u2192 Preview", keys: ["Mod-Shift-e"], group: "Views", reference: "AI Matrx" },
+  { id: "help", label: "Keyboard shortcuts", keys: ["Mod-/"], group: "Views", reference: "Docs" }
+];
+const TYPED_TRIGGERS = /* @__PURE__ */ new Set(["/", "{{"]);
+function formatKeys(keys, apple) {
+  return keys.split("-").map((part) => {
+    if (part === "Mod") return apple ? "\u2318" : "Ctrl";
+    if (part === "Alt") return apple ? "\u2325" : "Alt";
+    if (part === "Shift") return apple ? "\u21E7" : "Shift";
+    if (part === "ArrowUp") return "\u2191";
+    if (part === "ArrowDown") return "\u2193";
+    return part.length === 1 ? part.toUpperCase() : part;
+  }).join(apple ? "" : "+");
+}
+export {
+  RICH_EDITOR_SHORTCUTS,
+  TYPED_TRIGGERS,
+  formatKeys
+};

package/dist/core/source-format.d.ts

@@ -0,0 +1,28 @@
+export interface SourceChange {
+    from: number;
+    to: number;
+    insert: string;
+}
+export interface SourceEditResult {
+    changes: SourceChange[];
+    /** New selection, in the text AFTER the changes. */
+    anchor: number;
+    head: number;
+}
+/** Wrap the selection in `marker`, or unwrap it when it already is. */
+export declare function toggleWrap(text: string, from: number, to: number, marker: string): SourceEditResult;
+/**
+ * Give every line the selection touches `prefix` (replacing any heading /
+ * list / quote prefix it has). `null` clears it. Numbered prefixes count up.
+ */
+export declare function setLinePrefix(text: string, from: number, to: number, prefix: string | null): SourceEditResult;
+/** `[selection](url)` — the cursor lands in the url when none is given. */
+export declare function makeLink(text: string, from: number, to: number, url?: string): SourceEditResult;
+/** Apply a result to a string (tests and non-CodeMirror hosts). */
+export declare function applySourceEdit(text: string, result: SourceEditResult): string;
+/**
+ * Enter at the end of a list item or quote line continues it (next bullet,
+ * next number, an open checkbox, the quote prefix); Enter on an EMPTY item
+ * ends the list. Returns null when Enter should just insert a newline.
+ */
+export declare function continueMarkupOnEnter(text: string, pos: number): SourceEditResult | null;